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, plan_n_timesteps):
""" Place each vertex in a machine graph on a core in the machine.
:param MachineGraph machine_graph: The machine_graph to place
:param ~spinn_machine.Machine machine: A SpiNNaker machine object.
:param int plan_n_timesteps: number of timesteps to plan for
:return placements: Placements of vertices on the machine
:rtype: Placements
"""
# 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(machine_graph.n_vertices,
"Placing graph vertices")
resource_tracker = ResourceTracker(
machine, plan_n_timesteps, self._generate_random_chips(machine))
vertices_on_same_chip = get_same_chip_vertex_groups(machine_graph)
vertices_placed = set()
for vertex in progress.over(vertices):
if vertex not in vertices_placed:
vertices_placed.update(
self._place_vertex(vertex, resource_tracker, machine,
placements, vertices_on_same_chip))
return placements
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 each vertex in a machine graph on a core in the machine.
:param machine_graph: The machine_graph to place
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:param machine: A SpiNNaker machine object.
:type machine: :py:class:`spinn_machine.Machine`
:param plan_n_timesteps: number of timesteps to plan for
:type plan_n_timesteps: int
:return placements: Placements of vertices on the machine
:rtype :py:class:`pacman.model.placements.Placements`
"""
# 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(machine_graph.n_vertices,
"Placing graph vertices")
resource_tracker = ResourceTracker(
machine, plan_n_timesteps, self._generate_random_chips(machine))
vertices_on_same_chip = get_same_chip_vertex_groups(machine_graph)
vertices_placed = set()
for vertex in progress.over(vertices):
if vertex not in vertices_placed:
vertices_placed.update(self._place_vertex(
vertex, resource_tracker, machine, placements,
vertices_on_same_chip))
return placements
def _check_constraints(
self, vertices, additional_placement_constraints=None):
placement_constraints = {
RadialPlacementFromChipConstraint, SameChipAsConstraint
}
if additional_placement_constraints is not None:
placement_constraints.update(additional_placement_constraints)
ResourceTracker.check_constraints(
vertices, additional_placement_constraints=placement_constraints)
def _check_constraints(self,
vertices,
additional_placement_constraints=None):
if additional_placement_constraints is not None:
placement_constraints = additional_placement_constraints
else:
placement_constraints = {}
ResourceTracker.check_constraints(
vertices, additional_placement_constraints=placement_constraints)
def __gather_placements_with_tags(placement, collector):
"""
:param Placement placement:
:param list(Placement) collector:
"""
requires = placement.vertex.resources_required
if requires.iptags or requires.reverse_iptags:
ResourceTracker.check_constraints([placement.vertex])
collector.append(placement)
def _check_constraints(self,
vertices,
additional_placement_constraints=None):
placement_constraints = {
RadialPlacementFromChipConstraint, SameChipAsConstraint
}
if additional_placement_constraints is not None:
placement_constraints.update(additional_placement_constraints)
ResourceTracker.check_constraints(
vertices, additional_placement_constraints=placement_constraints)
def _check_constraints(
self, vertices, additional_placement_constraints=None):
""" Ensure that the algorithm conforms to any required constraints.
:param list(AbstractVertex) vertices:
The vertices for which to check the constraints
:param set(AbstractPlacerConstraint) additional_placement_constraints:
Additional placement constraints supported by the algorithm doing
this check
"""
placement_constraints = {SameChipAsConstraint}
if additional_placement_constraints is not None:
placement_constraints.update(additional_placement_constraints)
ResourceTracker.check_constraints(
vertices, additional_placement_constraints=placement_constraints)
def __call__(self,
app_graph,
machine,
plan_n_time_steps,
pre_allocated_resources=None):
"""
:param ApplicationGraph app_graph: The application_graph to partition
:param ~spinn_machine.Machine machine:
The machine with respect to which to partition the application
graph
:param plan_n_time_steps:
the number of time steps to plan to run for
:type plan_n_time_steps: int or None
:param pre_allocated_resources:
res needed to be preallocated before making new machine vertices
:type pre_allocated_resources: PreAllocatedResourceContainer or None
:return:
A machine_graph of partitioned vertices and partitioned edges,
and the number of chips needed to satisfy this partitioning.
:rtype: tuple(MachineGraph, int)
:raise PacmanPartitionException:
If something goes wrong with the partitioning
"""
# check resource tracker can handle constraints
ResourceTracker.check_constraints(app_graph.vertices)
# get the setup objects
(machine_graph, resource_tracker, vertices,
progress) = (self.__setup_objects(app_graph, machine,
plan_n_time_steps,
pre_allocated_resources))
self.__set_max_atoms_to_splitters(app_graph)
# Partition one vertex at a time
for vertex in progress.over(vertices):
vertex.splitter.split(resource_tracker, machine_graph)
# process edges
self.__process_machine_edges(app_graph, machine_graph,
resource_tracker)
# return the accepted things
return machine_graph, resource_tracker.chips_used
def _check_constraints(
self, vertices, additional_placement_constraints=None):
""" Ensure that the algorithm conforms to any required constraints.
:param vertices: The vertices for which to check the constraints
:type vertices: dict()
:param additional_placement_constraints:\
Additional placement constraints supported by the algorithm doing\
this check
:type additional_placement_constraints: set of \
:py:class:`pacman.model.constraints.placer_constraints.AbstractPlacerConstraint`
"""
placement_constraints = {SameChipAsConstraint}
if additional_placement_constraints is not None:
placement_constraints.update(additional_placement_constraints)
ResourceTracker.check_constraints(
vertices, additional_placement_constraints=placement_constraints)
def __call__(self, machine_graph, machine):
# 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(machine_graph.n_vertices,
"Placing graph vertices")
resource_tracker = ResourceTracker(
machine, self._generate_random_chips(machine))
vertices_on_same_chip = get_same_chip_vertex_groups(machine_graph)
vertices_placed = set()
for vertex in progress.over(vertices):
if vertex not in vertices_placed:
vertices_placed.update(
self._place_vertex(vertex, resource_tracker, machine,
placements, vertices_on_same_chip))
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):
"""
: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, graph, machine, plan_n_timesteps):
"""
:param graph: The application_graph to partition
:type graph:\
:py:class:`pacman.model.graphs.application.ApplicationGraph`
: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 machine graph
:rtype:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:raise pacman.exceptions.PacmanPartitionException:\
If something goes wrong with the partitioning
"""
ResourceTracker.check_constraints(graph.vertices)
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
supported_constraints=[
MaxVertexAtomsConstraint, FixedVertexAtomsConstraint],
abstract_constraint_type=AbstractPartitionerConstraint)
# start progress bar
progress = ProgressBar(graph.n_vertices, "Partitioning graph vertices")
machine_graph = MachineGraph("Machine graph for " + graph.label)
graph_mapper = GraphMapper()
resource_tracker = ResourceTracker(machine, plan_n_timesteps)
# Partition one vertex at a time
for vertex in progress.over(graph.vertices):
self._partition_one_application_vertex(
vertex, resource_tracker, machine_graph, graph_mapper,
plan_n_timesteps)
generate_machine_edges(machine_graph, graph_mapper, graph)
return machine_graph, graph_mapper, resource_tracker.chips_used
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, graph, machine):
"""
:param graph: The application_graph to partition
:type graph:\
:py:class:`pacman.model.graphs.application.ApplicationGraph`
:param machine:\
The machine with respect to which to partition the application\
graph
:type machine: :py:class:`spinn_machine.Machine`
:return: A machine graph
:rtype:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:raise pacman.exceptions.PacmanPartitionException:\
If something goes wrong with the partitioning
"""
ResourceTracker.check_constraints(graph.vertices)
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
supported_constraints=[
MaxVertexAtomsConstraint, FixedVertexAtomsConstraint
],
abstract_constraint_type=AbstractPartitionerConstraint)
# start progress bar
progress = ProgressBar(graph.n_vertices, "Partitioning graph vertices")
machine_graph = MachineGraph("Machine graph for " + graph.label)
graph_mapper = GraphMapper()
resource_tracker = ResourceTracker(machine)
# Partition one vertex at a time
for vertex in progress.over(graph.vertices):
self._partition_one_application_vertex(vertex, resource_tracker,
machine_graph, graph_mapper)
utils.generate_machine_edges(machine_graph, graph_mapper, graph)
return machine_graph, graph_mapper, resource_tracker.chips_used
def __call__(
self, graph, machine, plan_n_timesteps,
preallocated_resources=None):
"""
:param graph: The application_graph to partition
:type graph:\
:py:class:`pacman.model.graph.application.ApplicationGraph`
: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 machine_graph of partitioned vertices and partitioned edges
:rtype:\
:py:class:`pacman.model.graph.machine.MachineGraph`
:raise pacman.exceptions.PacmanPartitionException: \
If something goes wrong with the partitioning
"""
ResourceTracker.check_constraints(graph.vertices)
utils.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
abstract_constraint_type=AbstractPartitionerConstraint,
supported_constraints=[MaxVertexAtomsConstraint,
SameAtomsAsVertexConstraint,
FixedVertexAtomsConstraint])
# Load the vertices and create the machine_graph to fill
machine_graph = MachineGraph(
label="partitioned graph for {}".format(graph.label))
graph_mapper = GraphMapper()
# sort out vertex's by placement constraints
vertices = sort_vertices_by_known_constraints(graph.vertices)
# Set up the progress
n_atoms = 0
for vertex in vertices:
n_atoms += vertex.n_atoms
progress = ProgressBar(n_atoms, "Partitioning graph vertices")
resource_tracker = ResourceTracker(
machine, plan_n_timesteps,
preallocated_resources=preallocated_resources)
# Group vertices that are supposed to be the same size
vertex_groups = get_same_size_vertex_groups(vertices)
# Partition one vertex at a time
for vertex in vertices:
# check that the vertex hasn't already been partitioned
machine_vertices = graph_mapper.get_machine_vertices(vertex)
# if not, partition
if machine_vertices is None:
self._partition_vertex(
vertex, plan_n_timesteps, machine_graph, graph_mapper,
resource_tracker, progress, vertex_groups)
progress.end()
generate_machine_edges(machine_graph, graph_mapper, graph)
return machine_graph, graph_mapper, resource_tracker.chips_used
def __call__(self, graph, machine, preallocated_resources=None):
"""
:param graph: The application_graph to partition
:type graph:\
:py:class:`pacman.model.graph.application.ApplicationGraph`
:param machine: The machine with respect to which to partition the\
application_graph
:type machine: :py:class:`spinn_machine.Machine`
:return: \
A machine_graph of partitioned vertices and partitioned edges
:rtype:\
:py:class:`pacman.model.graph.machine.MachineGraph`
:raise pacman.exceptions.PacmanPartitionException: \
If something goes wrong with the partitioning
"""
ResourceTracker.check_constraints(graph.vertices)
utils.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
abstract_constraint_type=AbstractPartitionerConstraint,
supported_constraints=[MaxVertexAtomsConstraint,
SameAtomsAsVertexConstraint,
FixedVertexAtomsConstraint])
# Load the vertices and create the machine_graph to fill
machine_graph = MachineGraph(
label="partitioned graph for {}".format(graph.label))
graph_mapper = GraphMapper()
# sort out vertex's by placement constraints
vertices = placer_utils.sort_vertices_by_known_constraints(
graph.vertices)
# Set up the progress
n_atoms = 0
for vertex in vertices:
n_atoms += vertex.n_atoms
progress = ProgressBar(n_atoms, "Partitioning graph vertices")
resource_tracker = ResourceTracker(
machine, preallocated_resources=preallocated_resources)
# Group vertices that are supposed to be the same size
vertex_groups = partition_utils.get_same_size_vertex_groups(vertices)
# Partition one vertex at a time
for vertex in vertices:
# check that the vertex hasn't already been partitioned
machine_vertices = graph_mapper.get_machine_vertices(vertex)
# if not, partition
if machine_vertices is None:
self._partition_vertex(
vertex, machine_graph, graph_mapper, resource_tracker,
progress, vertex_groups)
progress.end()
partition_utils.generate_machine_edges(
machine_graph, graph_mapper, graph)
return machine_graph, graph_mapper, resource_tracker.chips_used
def _gather_placements_with_tags(self, placement, collector):
if (placement.vertex.resources_required.iptags or
placement.vertex.resources_required.reverse_iptags):
ResourceTracker.check_constraints([placement.vertex])
collector.append(placement)
def _gather_placements_with_tags(self, placement, collector):
if (placement.vertex.resources_required.iptags
or placement.vertex.resources_required.reverse_iptags):
ResourceTracker.check_constraints([placement.vertex])
collector.append(placement)
