def __call__(self, subgraph, graph_mapper):
"""
:param subgraph: the subgraph whose edges are to be filtered
:param graph_mapper: the graph mapper between partitionable and \
partitioned graphs.
:return: a new graph mapper and partitioned graph
"""
new_sub_graph = PartitionedGraph(label=subgraph.label)
new_graph_mapper = GraphMapper(graph_mapper.first_graph_label,
subgraph.label)
# create progress bar
progress_bar = ProgressBar(
len(subgraph.subvertices) + len(subgraph.subedges),
"Filtering edges")
# add the subverts directly, as they wont be pruned.
for subvert in subgraph.subvertices:
new_sub_graph.add_subvertex(subvert)
associated_vertex = graph_mapper.get_vertex_from_subvertex(subvert)
vertex_slice = graph_mapper.get_subvertex_slice(subvert)
new_graph_mapper.add_subvertex(subvertex=subvert,
vertex_slice=vertex_slice,
vertex=associated_vertex)
progress_bar.update()
# start checking subedges to decide which ones need pruning....
for subvert in subgraph.subvertices:
out_going_partitions = \
subgraph.outgoing_edges_partitions_from_vertex(subvert)
for partitioner_identifier in out_going_partitions:
for subedge in \
out_going_partitions[partitioner_identifier].edges:
if not self._is_filterable(subedge, graph_mapper):
logger.debug(
"this subedge was not pruned {}".format(subedge))
new_sub_graph.add_subedge(subedge,
partitioner_identifier)
associated_edge = graph_mapper.\
get_partitionable_edge_from_partitioned_edge(
subedge)
new_graph_mapper.add_partitioned_edge(
subedge, associated_edge)
else:
logger.debug(
"this subedge was pruned {}".format(subedge))
progress_bar.update()
progress_bar.end()
# returned the pruned partitioned_graph and graph_mapper
return {
'new_sub_graph': new_sub_graph,
'new_graph_mapper': new_graph_mapper
}
def run(self, subgraph, graph_mapper):
new_sub_graph = PartitionedGraph(label=subgraph.label)
new_graph_mapper = GraphMapper(graph_mapper.first_graph_label,
subgraph.label)
# create progress bar
progress_bar = \
ProgressBar(len(subgraph.subvertices) + len(subgraph.subedges),
"on checking which subedges are filterable given "
"heuristics")
# add the subverts directly, as they wont be pruned.
for subvert in subgraph.subvertices:
new_sub_graph.add_subvertex(subvert)
associated_vertex = graph_mapper.get_vertex_from_subvertex(subvert)
vertex_slice = graph_mapper.get_subvertex_slice(subvert)
new_graph_mapper.add_subvertex(subvertex=subvert,
vertex_slice=vertex_slice,
vertex=associated_vertex)
progress_bar.update()
# start checking subedges to decide which ones need pruning....
for subedge in subgraph.subedges:
if not self._is_filterable(subedge, graph_mapper):
logger.debug("this subedge was not pruned {}".format(subedge))
new_sub_graph.add_subedge(subedge)
associated_edge = graph_mapper.\
get_partitionable_edge_from_partitioned_edge(subedge)
new_graph_mapper.add_partitioned_edge(subedge, associated_edge)
else:
logger.debug("this subedge was pruned {}".format(subedge))
progress_bar.update()
progress_bar.end()
# returned the pruned partitioned_graph and graph_mapper
return new_sub_graph, new_graph_mapper
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
