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 __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):
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=graph.vertices,
supported_constraints=[PartitionerMaximumSizeConstraint],
abstract_constraint_type=AbstractPartitionerConstraint)
# start progress bar
progress_bar = ProgressBar(len(graph.vertices),
"Partitioning graph vertices")
vertices = graph.vertices
subgraph = PartitionedGraph(label="partitioned_graph for partitionable"
"_graph {}".format(graph.label))
graph_to_subgraph_mapper = GraphMapper(graph.label, subgraph.label)
resource_tracker = ResourceTracker(machine)
# Partition one vertex at a time
for vertex in vertices:
# Get the usage of the first atom, then assume that this
# will be the usage of all the atoms
requirements = vertex.get_resources_used_by_atoms(Slice(0, 1),
graph)
# Locate the maximum resources available
max_resources_available = \
resource_tracker.get_maximum_constrained_resources_available(
vertex.constraints)
# Find the ratio of each of the resources - if 0 is required,
# assume the ratio is the max available
atoms_per_sdram = self._get_ratio(
max_resources_available.sdram.get_value(),
requirements.sdram.get_value())
atoms_per_dtcm = self._get_ratio(
max_resources_available.dtcm.get_value(),
requirements.dtcm.get_value())
atoms_per_cpu = self._get_ratio(
max_resources_available.cpu.get_value(),
requirements.cpu.get_value())
max_atom_values = [atoms_per_sdram, atoms_per_dtcm, atoms_per_cpu]
max_atoms_constraints = utility_calls.locate_constraints_of_type(
vertex.constraints, PartitionerMaximumSizeConstraint)
for max_atom_constraint in max_atoms_constraints:
max_atom_values.append(max_atom_constraint.size)
atoms_per_core = min(max_atom_values)
# Partition into subvertices
counted = 0
while counted < vertex.n_atoms:
# Determine subvertex size
remaining = vertex.n_atoms - counted
if remaining > atoms_per_core:
alloc = atoms_per_core
else:
alloc = remaining
# Create and store new subvertex, and increment elements
# counted
if counted < 0 or counted + alloc - 1 < 0:
raise PacmanPartitionException("Not enough resources"
" available to create"
" subvertex")
vertex_slice = Slice(counted, counted + (alloc - 1))
subvertex_usage = vertex.get_resources_used_by_atoms(
vertex_slice, graph)
subvert = vertex.create_subvertex(
vertex_slice, subvertex_usage,
"{}:{}:{}".format(vertex.label, counted,
(counted + (alloc - 1))),
partition_algorithm_utilities.
get_remaining_constraints(vertex))
subgraph.add_subvertex(subvert)
graph_to_subgraph_mapper.add_subvertex(
subvert, vertex_slice, vertex)
counted = counted + alloc
# update allocated resources
resource_tracker.allocate_constrained_resources(
subvertex_usage, vertex.constraints)
# update and end progress bars as needed
progress_bar.update()
progress_bar.end()
partition_algorithm_utilities.generate_sub_edges(
subgraph, graph_to_subgraph_mapper, graph)
return {'Partitioned_graph': subgraph,
'Graph_mapper': graph_to_subgraph_mapper}
