def _allocate_one_to_one_group(
resource_tracker, vertices, progress, placements, chips,
all_vertices_placed, machine_graph):
"""
:param ResourceTracker resource_tracker:
:param list(MachineVertex) vertices:
:param ~spinn_utilities.progress_bar.ProgressBar progress:
:param Placements placements:
:param chips:
:type chips: iterable(tuple(int, int)) or None
:param MachineGraph machine_graph: machine graph
:param set(MachineVertex) all_vertices_placed:
:rtype: bool
"""
try:
allocs = resource_tracker.allocate_constrained_group_resources(
create_requirement_collections(vertices, machine_graph),
chips)
# allocate cores to vertices
for vertex, (x, y, p, _, _) in progress.over(
zip(vertices, allocs), False):
placements.add_placement(Placement(vertex, x, y, p))
all_vertices_placed.add(vertex)
return True
except (PacmanValueError, PacmanException,
PacmanInvalidParameterException):
return False
def _place_same_chip_verts(self, same_chip_vertex_groups, chips_in_order,
placements, progress_bar, resource_tracker,
placed_vertices, cost_per_chip, machine_graph,
n_keys_map):
""" places verts which have to be on the same chip on minimum chip.
:param same_chip_vertex_groups:
groups of verts which want to be on the same chip.
:type same_chip_vertex_groups: dict(MachineVertex, set(MachineVertex))
:param chips_in_order: chips in radial order from mid machine
:type chips_in_order: iterable(tuple(int,int))
:param Placements placements: placements holder
:param ~spinn_utilities.progress_bar.ProgressBar progress_bar:
progress bar
:param ResourceTracker resource_tracker: resource tracker
:param set(MachineVertex) placed_vertices:
vertices which have already been placed
:param cost_per_chip: map between (x,y) and the cost of packets
:type cost_per_chip: dict(tuple(int, int), int)
:param MachineGraph machine_graph:
:param AbstractMachinePartitionNKeysMap n_keys_map:
:rtype: None
"""
for vertex in same_chip_vertex_groups.keys():
if len(same_chip_vertex_groups[vertex]) != 1:
if vertex not in placed_vertices:
to_do_as_group = list()
for other_vert in same_chip_vertex_groups[vertex]:
if other_vert not in placed_vertices:
to_do_as_group.extend(
create_requirement_collections([other_vert],
machine_graph))
# allocate as a group to sorted chips so that ones with
# least incoming packets are considered first
results = \
resource_tracker.allocate_constrained_group_resources(
to_do_as_group, chips=chips_in_order)
# create placements and add cost to the chip
for (x, y, p, _, _), placed_vertex in zip(
results, same_chip_vertex_groups[vertex]):
placements.add_placement(
Placement(placed_vertex, x, y, p))
placed_vertices.add(placed_vertex)
cost_per_chip[x, y] += self._get_cost(
placed_vertex, machine_graph, n_keys_map)
# resort the chips, as no idea where in the list the resource
# tracker selected
chips_in_order = self._sort_chips_based_off_incoming_cost(
chips_in_order, cost_per_chip)
# update progress bar to cover one cycle of all the verts in the graph
progress_bar.update(len(machine_graph.vertices))
def _place_vertex(self, vertex, resource_tracker, machine, placements,
vertices_on_same_chip, machine_graph):
"""
:param MachineVertex vertex:
:param ResourceTracker resource_tracker:
:param ~spinn_machine.Machine machine:
:param Placements placements:
:param vertices_on_same_chip:
:type vertices_on_same_chip: dict(MachineVertex, set(MachineVertex))
:param MachineGraph machine_graph:
:rtype: set(MachineVertex)
"""
vertices = vertices_on_same_chip[vertex]
# Check for the radial placement constraint
radial_constraints = [
c for v in vertices for c in v.constraints
if isinstance(c, RadialPlacementFromChipConstraint)
]
start_x, start_y = self._get_start(radial_constraints)
chips = None
if start_x is not None and start_y is not None:
chips = self._generate_radial_chips(machine, resource_tracker,
start_x, start_y)
if len(vertices) > 1:
assigned_values = \
resource_tracker.allocate_constrained_group_resources(
create_requirement_collections(vertices, machine_graph),
chips=chips)
for (x, y, p, _, _), vert in zip(assigned_values, vertices):
placement = Placement(vert, x, y, p)
placements.add_placement(placement)
else:
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
vertex.resources_required, vertex.constraints, chips=chips)
placement = Placement(vertex, x, y, p)
placements.add_placement(placement)
return vertices
def _allocate_same_chip_as_group(
vertex, placements, tracker, same_chip_vertex_groups,
all_vertices_placed, progress, machine_graph):
"""
:param MachineVertex vertex:
:param Placements placements:
:param ResourceTracker tracker:
:param dict(MachineVertex,set(MachineVertex)) same_chip_vertex_groups:
:param ~spinn_utilities.progress_bar.ProgressBar progress:
:param MachineGraph machine_graph:
"""
if vertex not in all_vertices_placed:
# get vert's
vertices = same_chip_vertex_groups[vertex]
resources = tracker.allocate_constrained_group_resources(
create_requirement_collections(vertices, machine_graph))
for (x, y, p, _, _), v in progress.over(
zip(resources, vertices), False):
placements.add_placement(Placement(v, x, y, p))
all_vertices_placed.add(v)
