def __call__(self, machine_graph, machine):
""" Place a machine_graph so that each vertex is placed on a core
:param machine_graph: The machine_graph to place
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:return: A set of placements
:rtype: :py:class:`pacman.model.placements.Placements`
:raise pacman.exceptions.PacmanPlaceException: \
If something goes wrong with the placement
"""
# check that the algorithm can handle the constraints
ResourceTracker.check_constraints(machine_graph.vertices)
placements = Placements()
vertices = sort_vertices_by_known_constraints(machine_graph.vertices)
# Iterate over vertices and generate placements
progress = ProgressBar(vertices, "Placing graph vertices")
resource_tracker = ResourceTracker(machine)
for vertex in progress.over(vertices):
# Create and store a new placement anywhere on the board
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
vertex.resources_required, vertex.constraints, None)
placement = Placement(vertex, x, y, p)
placements.add_placement(placement)
return placements
def __call__(self, machine_graph, machine, plan_n_timesteps):
""" Place a machine_graph so that each vertex is placed on a core
:param machine_graph: The machine_graph to place
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:param machine:\
The machine with respect to which to partition the application\
graph
:type machine: :py:class:`spinn_machine.Machine`
:param plan_n_timesteps: number of timesteps to plan for
:type plan_n_timesteps: int
:return: A set of placements
:rtype: :py:class:`pacman.model.placements.Placements`
:raise pacman.exceptions.PacmanPlaceException: \
If something goes wrong with the placement
"""
# check that the algorithm can handle the constraints
ResourceTracker.check_constraints(machine_graph.vertices)
placements = Placements()
vertices = sort_vertices_by_known_constraints(machine_graph.vertices)
# Iterate over vertices and generate placements
progress = ProgressBar(vertices, "Placing graph vertices")
resource_tracker = ResourceTracker(machine, plan_n_timesteps)
for vertex in progress.over(vertices):
# Create and store a new placement anywhere on the board
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
vertex.resources_required, vertex.constraints, None)
placement = Placement(vertex, x, y, p)
placements.add_placement(placement)
return placements
def __call__(self, machine_graph, machine):
"""
:param machine_graph: The machine_graph to measure
:type machine_graph:\
:py:class:`pacman.model.graph.machine.MachineGraph`
:return: The size of the graph in number of chips
:rtype: int
"""
# check that the algorithm can handle the constraints
ResourceTracker.check_constraints(machine_graph.vertices)
ordered_vertices = sort_vertices_by_known_constraints(
machine_graph.vertices)
# Iterate over vertices and allocate
progress = ProgressBar(machine_graph.n_vertices, "Measuring the graph")
resource_tracker = ResourceTracker(machine)
for vertex in progress.over(ordered_vertices):
resource_tracker.allocate_constrained_resources(
vertex.resources_required, vertex.constraints)
return len(resource_tracker.keys)
def __call__(self, machine_graph, machine, plan_n_timesteps):
"""
:param ~.MachineGraph machine_graph:
:param ~.Machine machine:
:param int plan_n_timesteps:
:rtype: int
"""
# check that the algorithm can handle the constraints
ResourceTracker.check_constraints(machine_graph.vertices)
ordered_vertices = sort_vertices_by_known_constraints(
machine_graph.vertices)
# Iterate over vertices and allocate
progress = ProgressBar(machine_graph.n_vertices, "Measuring the graph")
resource_tracker = ResourceTracker(machine, plan_n_timesteps)
for vertex in progress.over(ordered_vertices):
resource_tracker.allocate_constrained_resources(
vertex.resources_required, vertex.constraints)
return len(resource_tracker.keys)
def __call__(self, machine_graph, machine):
"""
:param machine_graph: The machine_graph to measure
:type machine_graph:\
:py:class:`pacman.model.graph.machine.MachineGraph`
:return: The size of the graph in number of chips
:rtype: int
"""
# check that the algorithm can handle the constraints
ResourceTracker.check_constraints(machine_graph.vertices)
ordered_vertices = sort_vertices_by_known_constraints(
machine_graph.vertices)
# Iterate over vertices and allocate
progress = ProgressBar(machine_graph.n_vertices, "Measuring the graph")
resource_tracker = ResourceTracker(machine)
for vertex in progress.over(ordered_vertices):
resource_tracker.allocate_constrained_resources(
vertex.resources_required, vertex.constraints)
return len(resource_tracker.keys)
def __call__(self, machine_graph, machine, n_keys_map, plan_n_timesteps):
"""
:param MachineGraph machine_graph: the machine graph
:param ~spinn_machine.Machine machine: the SpiNNaker machine
:param AbstractMachinePartitionNKeysMap n_keys_map:
the n keys from partition map
:param int plan_n_timesteps: number of timesteps to plan for
:return: placements.
:rtype: Placements
"""
# create progress bar
progress_bar = ProgressBar(
(machine_graph.n_vertices * self.ITERATIONS) + self.STEPS,
"Placing graph vertices via spreading over an entire machine")
# check that the algorithm can handle the constraints
self._check_constraints(
machine_graph.vertices,
additional_placement_constraints={SameChipAsConstraint})
progress_bar.update()
# get same chip groups
same_chip_vertex_groups = get_same_chip_vertex_groups(machine_graph)
progress_bar.update()
# get chip and core placed verts
hard_chip_constraints = self._locate_hard_placement_verts(
machine_graph)
progress_bar.update()
# get one to one groups
one_to_one_groups = create_vertices_groups(
machine_graph.vertices,
functools.partial(self._find_one_to_one_vertices,
graph=machine_graph))
progress_bar.update()
# sort chips so that they are radial from a given point and other
# init data structs
chips_in_order = self._determine_chip_list(machine)
resource_tracker = ResourceTracker(machine,
plan_n_timesteps,
chips=chips_in_order)
placements = Placements()
placed_vertices = set()
cost_per_chip = defaultdict(int)
progress_bar.update()
# allocate hard ones
for hard_vertex in hard_chip_constraints:
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
hard_vertex.resources_required, hard_vertex.constraints)
placements.add_placement(Placement(hard_vertex, x, y, p))
placed_vertices.add(hard_vertex)
cost_per_chip[x, y] += self._get_cost(hard_vertex, machine_graph,
n_keys_map)
# place groups of verts that need the same chip on the same chip,
self._place_same_chip_verts(same_chip_vertex_groups, chips_in_order,
placements, progress_bar, resource_tracker,
placed_vertices, cost_per_chip,
machine_graph, n_keys_map)
# place 1 group per chip if possible on same chip as any already
# placed verts. if not then radially from it.
self._place_one_to_one_verts(one_to_one_groups, chips_in_order,
placements, progress_bar,
resource_tracker, placed_vertices,
cost_per_chip, machine_graph, n_keys_map,
machine)
# place vertices which don't have annoying placement constraints.
# spread them over the chips so that they have minimal impact on the
# overall incoming packet cost per router.
self._place_left_over_verts(machine_graph, chips_in_order, placements,
progress_bar, resource_tracker,
placed_vertices, cost_per_chip, n_keys_map)
progress_bar.end()
# return the built placements
return placements
