def __call__(self, partitioned_graph, machine):
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[
PlacerRadialPlacementFromChipConstraint,
TagAllocatorRequireIptagConstraint,
TagAllocatorRequireReverseIptagConstraint,
PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(
machine, self._generate_radial_chips(machine))
for vertex in ordered_subverts:
self._place_vertex(vertex, resource_tracker, machine, placements)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def __call__(self, partitioned_graph, machine):
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[
PlacerRadialPlacementFromChipConstraint,
TagAllocatorRequireIptagConstraint,
TagAllocatorRequireReverseIptagConstraint,
PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(
machine, self._generate_radial_chips(machine))
for vertex in ordered_subverts:
self._place_vertex(vertex, resource_tracker, machine, placements)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def __call__(self, partitioned_graph, machine):
"""
:param partitioned_graph: The partitioned_graph to measure
:type partitioned_graph:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:return: The size of the graph in number of chips
:rtype: int
"""
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and allocate
progress_bar = ProgressBar(len(ordered_subverts),
"Measuring the partitioned graph")
resource_tracker = ResourceTracker(machine)
for subvertex in ordered_subverts:
resource_tracker.allocate_constrained_resources(
subvertex.resources_required, subvertex.constraints)
progress_bar.update()
progress_bar.end()
return {'n_chips': len(resource_tracker.keys)}
def _sort_vertices_for_one_to_one_connection(self, partitioned_graph):
"""
:param partitioned_graph: the partitioned graph of this application
:return: list of sorted vertices
"""
sorted_vertices = list()
found_list = list()
# order subverts based on constraint priority
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
for vertex in ordered_subverts:
incoming_edges = \
partitioned_graph.incoming_subedges_from_subvertex(vertex)
# do search if not already added and has incoming edges
if vertex not in found_list and len(incoming_edges) != 0:
chip_constraint = utility_calls.locate_constraints_of_type(
vertex.constraints, PlacerChipAndCoreConstraint)
# if has constraint, add first then add incoming
if len(chip_constraint) != 0:
one_to_one_incoming_edges = list()
one_to_one_incoming_edges.append(vertex)
sorted_vertices.append(one_to_one_incoming_edges)
found_list.append(vertex)
self.check_incoming_verts(one_to_one_incoming_edges,
vertex, partitioned_graph,
found_list)
else: # if no constraint add incoming then first
one_to_one_incoming_edges = list()
sorted_vertices.append(one_to_one_incoming_edges)
self.check_incoming_verts(one_to_one_incoming_edges,
vertex, partitioned_graph,
found_list)
one_to_one_incoming_edges.append(vertex)
found_list.append(vertex)
# locate vertices which have no output or input, and add them for
# placement
for vertex in ordered_subverts:
if vertex not in found_list:
listed_vertex = list()
listed_vertex.append(vertex)
sorted_vertices.append(listed_vertex)
return sorted_vertices
def __call__(self, partitioned_graph, machine):
""" Place a partitioned_graph so that each subvertex is placed on a\
core
:param partitioned_graph: The partitioned_graph to place
:type partitioned_graph:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:return: A set of placements
:rtype: :py:class:`pacman.model.placements.placements.Placements`
:raise pacman.exceptions.PacmanPlaceException: If something\
goes wrong with the placement
"""
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(machine)
for subvertex in ordered_subverts:
# Create and store a new placement anywhere on the board
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
subvertex.resources_required, subvertex.constraints)
placement = Placement(subvertex, x, y, p)
placements.add_placement(placement)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def __call__(self, partitioned_graph, machine):
""" Place a partitioned_graph so that each subvertex is placed on a\
core
:param partitioned_graph: The partitioned_graph to place
:type partitioned_graph:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:return: A set of placements
:rtype: :py:class:`pacman.model.placements.placements.Placements`
:raise pacman.exceptions.PacmanPlaceException: If something\
goes wrong with the placement
"""
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(machine)
for subvertex in ordered_subverts:
# Create and store a new placement anywhere on the board
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
subvertex.resources_required, subvertex.constraints)
placement = Placement(subvertex, x, y, p)
placements.add_placement(placement)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def __call__(self, graph, machine):
""" Partition a partitionable_graph so that each subvertex will fit\
on a processor within the machine
:param graph: The partitionable_graph to partition
:type graph:\
:py:class:`pacman.model.graph.partitionable_graph.PartitionableGraph`
:param machine: The machine with respect to which to partition the\
partitionable_graph
:type machine: :py:class:`spinn_machine.machine.Machine`
:return: A partitioned_graph of partitioned vertices and partitioned\
edges
:rtype:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:raise pacman.exceptions.PacmanPartitionException: If something\
goes wrong with the partitioning
"""
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
abstract_constraint_type=AbstractPartitionerConstraint,
supported_constraints=[PartitionerMaximumSizeConstraint,
PartitionerSameSizeAsVertexConstraint])
# Load the vertices and create the subgraph to fill
vertices = graph.vertices
subgraph = PartitionedGraph(
label="partitioned graph for {}".format(graph.label))
graph_mapper = GraphMapper(graph.label, subgraph.label)
# sort out vertex's by constraints
vertices = utility_calls.sort_objects_by_constraint_authority(vertices)
# Set up the progress
n_atoms = 0
for vertex in vertices:
n_atoms += vertex.n_atoms
progress_bar = ProgressBar(n_atoms, "Partitioning graph vertices")
resource_tracker = ResourceTracker(machine)
# Partition one vertex at a time
for vertex in vertices:
# check that the vertex hasn't already been partitioned
subverts_from_vertex = \
graph_mapper.get_subvertices_from_vertex(vertex)
# if not, partition
if subverts_from_vertex is None:
self._partition_vertex(vertex, subgraph, graph_mapper,
resource_tracker, graph)
progress_bar.update(vertex.n_atoms)
progress_bar.end()
partition_algorithm_utilities.generate_sub_edges(
subgraph, graph_mapper, graph)
results = dict()
results['partitioned_graph'] = subgraph
results['graph_mapper'] = graph_mapper
return results
def __call__(self, graph, machine):
""" Partition a partitionable_graph so that each subvertex will fit\
on a processor within the machine
:param graph: The partitionable_graph to partition
:type graph:\
:py:class:`pacman.model.graph.partitionable_graph.PartitionableGraph`
:param machine: The machine with respect to which to partition the\
partitionable_graph
:type machine: :py:class:`spinn_machine.machine.Machine`
:return: A partitioned_graph of partitioned vertices and partitioned\
edges
:rtype:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:raise pacman.exceptions.PacmanPartitionException: If something\
goes wrong with the partitioning
"""
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
abstract_constraint_type=AbstractPartitionerConstraint,
supported_constraints=[PartitionerMaximumSizeConstraint,
PartitionerSameSizeAsVertexConstraint])
# Load the vertices and create the subgraph to fill
vertices = graph.vertices
subgraph = PartitionedGraph(
label="partitioned graph for {}".format(graph.label))
graph_mapper = GraphMapper(graph.label, subgraph.label)
# sort out vertex's by constraints
vertices = utility_calls.sort_objects_by_constraint_authority(vertices)
# Set up the progress
n_atoms = 0
for vertex in vertices:
n_atoms += vertex.n_atoms
progress_bar = ProgressBar(n_atoms, "Partitioning graph vertices")
resource_tracker = ResourceTracker(machine)
# Partition one vertex at a time
for vertex in vertices:
# check that the vertex hasn't already been partitioned
subverts_from_vertex = \
graph_mapper.get_subvertices_from_vertex(vertex)
# if not, partition
if subverts_from_vertex is None:
self._partition_vertex(
vertex, subgraph, graph_mapper, resource_tracker, graph)
progress_bar.update(vertex.n_atoms)
progress_bar.end()
partition_algorithm_utilities.generate_sub_edges(
subgraph, graph_mapper, graph)
results = dict()
results['partitioned_graph'] = subgraph
results['graph_mapper'] = graph_mapper
results['nChips'] = len(resource_tracker.keys)
return results
