def test_ner_route_default():
unittest_setup()
graph = MachineGraph("Test")
machine = virtual_machine(8, 8)
placements = Placements()
source_vertex = SimpleMachineVertex(None)
graph.add_vertex(source_vertex)
placements.add_placement(Placement(source_vertex, 0, 0, 1))
target_vertex = SimpleMachineVertex(None)
graph.add_vertex(target_vertex)
placements.add_placement(Placement(target_vertex, 0, 2, 1))
edge = MachineEdge(source_vertex, target_vertex)
graph.add_edge(edge, "Test")
partition = graph.get_outgoing_partition_for_edge(edge)
routes = ner_route(graph, machine, placements)
source_route = routes.get_entries_for_router(0, 0)[partition]
assert (not source_route.defaultable)
mid_route = routes.get_entries_for_router(0, 1)[partition]
print(mid_route.incoming_link, mid_route.link_ids)
assert (mid_route.defaultable)
end_route = routes.get_entries_for_router(0, 2)[partition]
assert (not end_route.defaultable)
def test_sdram_links():
""" Test sdram edges which should explode
"""
# Create a graph
machine_graph = MachineGraph("Test")
# Connect a set of vertices in a chain of length 3
last_vertex = None
for x in range(20):
vertex = SimpleMachineVertex(
resources=ResourceContainer(),
label="Vertex_{}".format(x), sdram_cost=20)
machine_graph.add_vertex(vertex)
last_vertex = vertex
for vertex in machine_graph.vertices:
machine_graph.add_outgoing_edge_partition(
ConstantSDRAMMachinePartition(
identifier="SDRAM", pre_vertex=vertex, label="bacon"))
edge = SDRAMMachineEdge(vertex, last_vertex, "bacon", app_edge=None)
machine_graph.add_edge(edge, "SDRAM")
n_keys_map = DictBasedMachinePartitionNKeysMap()
# Do placements
machine = virtual_machine(width=8, height=8)
try:
SpreaderPlacer()(machine_graph, machine, n_keys_map,
plan_n_timesteps=1000)
raise Exception("should blow up here")
except PacmanException:
pass
def _do_test(self, placer):
machine = VirtualMachine(width=8, height=8)
graph = MachineGraph("Test")
vertices = [
SimpleMachineVertex(ResourceContainer(), label="v{}".format(i))
for i in range(100)
]
for vertex in vertices:
graph.add_vertex(vertex)
same_vertices = [
SimpleMachineVertex(ResourceContainer(), label="same{}".format(i))
for i in range(10)
]
random.seed(12345)
sdram_edges = list()
for vertex in same_vertices:
graph.add_vertex(vertex)
for i in range(0, random.randint(1, 5)):
sdram_edge = MachineEdge(
vertex, vertices[random.randint(0, 99)],
traffic_type=EdgeTrafficType.SDRAM)
sdram_edges.append(sdram_edge)
graph.add_edge(sdram_edge, "Test")
placements = placer(graph, machine)
for edge in sdram_edges:
pre_place = placements.get_placement_of_vertex(edge.pre_vertex)
post_place = placements.get_placement_of_vertex(edge.post_vertex)
self.assert_(pre_place.x == post_place.x)
self.assert_(pre_place.y == post_place.y)
def test_call(self):
""" Test calling the binary gatherer normally
"""
vertex_1 = _TestVertexWithBinary("test.aplx", ExecutableType.RUNNING)
vertex_2 = _TestVertexWithBinary("test2.aplx", ExecutableType.RUNNING)
vertex_3 = _TestVertexWithBinary("test2.aplx", ExecutableType.RUNNING)
vertex_4 = _TestVertexWithoutBinary()
graph = MachineGraph("Test")
graph.add_vertices([vertex_1, vertex_2, vertex_3])
placements = Placements(placements=[
Placement(vertex_1, 0, 0, 0),
Placement(vertex_2, 0, 0, 1),
Placement(vertex_3, 0, 0, 2),
Placement(vertex_4, 0, 0, 3)
])
gatherer = GraphBinaryGatherer()
targets = gatherer.__call__(placements, graph, _TestExecutableFinder())
gatherer = LocateExecutableStartType()
start_type = gatherer.__call__(graph, placements)
self.assertEqual(next(iter(start_type)), ExecutableType.RUNNING)
self.assertEqual(targets.total_processors, 3)
test_cores = targets.get_cores_for_binary("test.aplx")
test_2_cores = targets.get_cores_for_binary("test2.aplx")
self.assertEqual(len(test_cores), 1)
self.assertEqual(len(test_2_cores), 2)
self.assertIn((0, 0, 0), test_cores)
self.assertIn((0, 0, 1), test_2_cores)
self.assertIn((0, 0, 2), test_2_cores)
def test_many_vertices(self):
vertices = list()
for i in range(20 * 17): # 51 atoms per each processor on 20 chips
vertices.append(
SimpleMachineVertex(0, 50,
get_resources_used_by_atoms(0, 50, []),
"vertex " + str(i)))
self.graph = ApplicationGraph("Graph", vertices)
self.graph_mapper = GraphMapper()
self.graph_mapper.add_vertices(vertices)
self.bp = RadialPlacer(self.machine, self.graph)
self.graph = MachineGraph(vertices=vertices)
placements = self.bp.place(self.graph, self.graph_mapper)
unorderdered_info = list()
for placement in placements.placements:
unorderdered_info.append(
(placement.vertex.label.split(" ")[0],
"{:<4}".format(placement.vertex.label.split(" ")[1]),
placement.vertex.n_atoms, 'x: ', placement.x, 'y: ',
placement.y, 'p: ', placement.p))
sorted_info = sorted(unorderdered_info, key=itemgetter(4, 6, 8))
pp(sorted_info)
pp("{}".format("=" * 50))
sorted_info = sorted(unorderdered_info, key=lambda x: int(x[1]))
pp(sorted_info)
def test_new_graph(self):
"""
tests that after building a machine graph, all partitined vertices
and partitioned edges are in existence
"""
vertices = list()
edges = list()
for i in range(10):
vertices.append(
SimpleMachineVertex(ResourceContainer(), "V{}".format(i)))
with self.assertRaises(NotImplementedError):
vertices[1].add_constraint(SameAtomsAsVertexConstraint(
vertices[4]))
vertices[4].add_constraint(SameAtomsAsVertexConstraint(
vertices[1]))
for i in range(5):
edges.append(MachineEdge(vertices[0], vertices[(i + 1)]))
for i in range(5, 10):
edges.append(MachineEdge(vertices[5], vertices[(i + 1) % 10]))
graph = MachineGraph("foo")
graph.add_vertices(vertices)
graph.add_outgoing_edge_partition(
MulticastEdgePartition(identifier="bar", pre_vertex=vertices[0]))
graph.add_outgoing_edge_partition(
MulticastEdgePartition(identifier="bar", pre_vertex=vertices[5]))
graph.add_edges(edges, "bar")
self.graph_there_and_back(graph)
def __call__(self, machine_graph, graph_mapper):
"""
:param machine_graph: the machine_graph whose edges are to be filtered
:param graph_mapper: the graph mapper between graphs
:return: a new graph mapper and machine graph
"""
new_machine_graph = MachineGraph(label=machine_graph.label)
new_graph_mapper = GraphMapper()
# create progress bar
progress = ProgressBar(
machine_graph.n_vertices +
machine_graph.n_outgoing_edge_partitions, "Filtering edges")
# add the vertices directly, as they wont be pruned.
for vertex in progress.over(machine_graph.vertices, False):
self._add_vertex_to_new_graph(vertex, graph_mapper,
new_machine_graph, new_graph_mapper)
# start checking edges to decide which ones need pruning....
for partition in progress.over(machine_graph.outgoing_edge_partitions):
for edge in partition.edges:
if self._is_filterable(edge, graph_mapper):
logger.debug("this edge was pruned %s", edge)
continue
logger.debug("this edge was not pruned %s", edge)
self._add_edge_to_new_graph(edge, partition, graph_mapper,
new_machine_graph,
new_graph_mapper)
# returned the pruned graph and graph_mapper
return new_machine_graph, new_graph_mapper
def __call__(self,
nengo_operator_graph,
machine,
nengo_random_number_generator,
pre_allocated_resources=None):
machine_graph = MachineGraph(label=constants.MACHINE_GRAPH_LABEL)
graph_mapper = GraphMapper()
self._resource_tracker = ResourceTracker(
machine, preallocated_resources=pre_allocated_resources)
progress_bar = ProgressBar(
total_number_of_things_to_do=(
len(nengo_operator_graph.vertices) +
len(nengo_operator_graph.outgoing_edge_partitions)),
string_describing_what_being_progressed="partitioning")
# convert application vertices into machine vertices
for operator in progress_bar.over(nengo_operator_graph.vertices,
False):
# create the machine verts
operator.create_machine_vertices(self._resource_tracker,
machine_graph, graph_mapper)
self._handle_edges(nengo_operator_graph, machine_graph, graph_mapper,
progress_bar, nengo_random_number_generator)
return machine_graph, graph_mapper, self._resource_tracker.chips_used
def __setup_objects(self, app_graph, machine, plan_n_time_steps,
pre_allocated_resources):
""" sets up the machine_graph, resource_tracker, vertices, \
progress bar.
:param ApplicationGraph app_graph: app graph
:param ~spinn_machine.Machine machine: machine
:param int plan_n_time_steps: the number of time steps to run for.
:param pre_allocated_resources: pre allocated res from other systems.
:type PreAllocatedResourceContainer or None
:return: (machine graph, res tracker, verts, progress bar)
:rtype: tuple(MachineGraph, ResourceTracker, list(ApplicationVertex),
~.ProgressBar)
"""
# Load the vertices and create the machine_graph to fill
machine_graph = MachineGraph(label="partitioned graph for {}".format(
app_graph.label),
application_graph=app_graph)
resource_tracker = ResourceTracker(
machine,
plan_n_time_steps,
preallocated_resources=pre_allocated_resources)
# sort out vertex's by placement constraints
vertices = sort_vertices_by_known_constraints(app_graph.vertices)
# Group vertices that are supposed to be the same size
self.order_vertices_for_dependent_splitters(vertices)
# Set up the progress
progress = ProgressBar(len(app_graph.vertices),
self.__PROGRESS_BAR_VERTICES)
return machine_graph, resource_tracker, vertices, progress
def test_virtual_placement(placer):
machine = virtual_machine(width=8, height=8)
graph = MachineGraph("Test")
virtual_vertex = MachineSpiNNakerLinkVertex(spinnaker_link_id=0)
graph.add_vertex(virtual_vertex)
extended_machine = MallocBasedChipIdAllocator()(machine, graph)
n_keys_map = DictBasedMachinePartitionNKeysMap()
inputs = {
"MemoryExtendedMachine": machine,
"MemoryMachine": machine,
"MemoryMachineGraph": graph,
"PlanNTimeSteps": 1000,
"MemoryMachinePartitionNKeysMap": n_keys_map
}
algorithms = [placer]
xml_paths = []
executor = PACMANAlgorithmExecutor(algorithms, [], inputs, [], [], [],
xml_paths)
executor.execute_mapping()
placements = executor.get_item("MemoryPlacements")
placement = placements.get_placement_of_vertex(virtual_vertex)
chip = extended_machine.get_chip_at(placement.x, placement.y)
assert chip.virtual
def setUp(self):
unittest_setup()
self.machine = virtual_machine(8, 8)
self.mach_graph = MachineGraph("machine")
self.vertices = list()
self.vertex1 = get_resourced_machine_vertex(0, 1, "First vertex")
self.vertex2 = get_resourced_machine_vertex(1, 5, "Second vertex")
self.vertex3 = get_resourced_machine_vertex(5, 10, "Third vertex")
self.vertex4 = get_resourced_machine_vertex(10, 100, "Fourth vertex")
self.vertices.append(self.vertex1)
self.mach_graph.add_vertex(self.vertex1)
self.vertices.append(self.vertex2)
self.mach_graph.add_vertex(self.vertex2)
self.vertices.append(self.vertex3)
self.mach_graph.add_vertex(self.vertex3)
self.vertices.append(self.vertex4)
self.mach_graph.add_vertex(self.vertex4)
self.edges = list()
edge1 = MachineEdge(self.vertex2, self.vertex3)
self.edges.append(edge1)
self.mach_graph.add_edge(edge1, "packet")
edge2 = MachineEdge(self.vertex2, self.vertex4)
self.edges.append(edge2)
self.mach_graph.add_edge(edge2, "packet")
edge3 = MachineEdge(self.vertex3, self.vertex4)
self.edges.append(edge3)
self.mach_graph.add_edge(edge3, "packet")
edge4 = MachineEdge(self.vertex3, self.vertex1)
self.edges.append(edge4)
self.plan_n_timesteps = 100
def test_get_vertices_from_vertex(self):
"""
test getting the vertex from a graph mapper via the vertex
"""
vertices = list()
app_graph = ApplicationGraph("bacon")
vert = SimpleTestVertex(10, "Some testing vertex")
app_graph.add_vertex(vert)
vertices.append(SimpleMachineVertex(None, ""))
vertices.append(SimpleMachineVertex(None, ""))
mac_graph = MachineGraph("cooked bacon", application_graph=app_graph)
vertex1 = SimpleMachineVertex(None,
"",
vertex_slice=Slice(0, 1),
app_vertex=vert)
vertex2 = SimpleMachineVertex(None,
"",
vertex_slice=Slice(2, 3),
app_vertex=vert)
mac_graph.add_vertex(vertex1)
mac_graph.add_vertex(vertex2)
returned_vertices = vert.machine_vertices
self.assertIn(vertex1, returned_vertices)
self.assertIn(vertex2, returned_vertices)
for v in vertices:
self.assertNotIn(v, returned_vertices)
def _integration_setup(self):
machine_graph = MachineGraph(label="test me you git")
n_keys_map = DictBasedMachinePartitionNKeysMap()
v1 = SimpleMachineVertex(ResourceContainer())
v2 = SimpleMachineVertex(ResourceContainer())
v3 = SimpleMachineVertex(ResourceContainer())
v4 = SimpleMachineVertex(ResourceContainer())
machine_graph.add_vertex(v1)
machine_graph.add_vertex(v2)
machine_graph.add_vertex(v3)
machine_graph.add_vertex(v4)
e1 = MachineEdge(v1, v2, label="e1")
e2 = MachineEdge(v1, v3, label="e2")
e3 = MachineEdge(v2, v3, label="e3")
e4 = MachineEdge(v1, v4, label="e4")
machine_graph.add_outgoing_edge_partition(
MulticastEdgePartition(identifier="part1", pre_vertex=v1))
machine_graph.add_outgoing_edge_partition(
MulticastEdgePartition(identifier="part2", pre_vertex=v2))
machine_graph.add_outgoing_edge_partition(
MulticastEdgePartition(identifier="part2", pre_vertex=v1))
machine_graph.add_edge(e1, "part1")
machine_graph.add_edge(e2, "part1")
machine_graph.add_edge(e3, "part2")
machine_graph.add_edge(e4, "part2")
for partition in machine_graph.outgoing_edge_partitions:
n_keys_map.set_n_keys_for_partition(partition, 24)
return machine_graph, n_keys_map, v1, v2, v3, v4, e1, e2, e3, e4
def test_routing(self):
graph = MachineGraph("Test")
machine = VirtualMachine(2, 2)
placements = Placements()
vertices = list()
for x in range(machine.max_chip_x + 1):
for y in range(machine.max_chip_y + 1):
chip = machine.get_chip_at(x, y)
if chip is not None:
for processor in chip.processors:
if not processor.is_monitor:
vertex = SimpleMachineVertex(
resources=ResourceContainer())
graph.add_vertex(vertex)
placements.add_placement(
Placement(vertex, x, y,
processor.processor_id))
vertices.append(vertex)
for vertex in vertices:
for vertex_to in vertices:
if vertex != vertex_to:
graph.add_edge(MachineEdge(vertex, vertex_to), "Test")
router = BasicDijkstraRouting()
routing_paths = router.__call__(placements, machine, graph)
for vertex in vertices:
vertices_reached = set()
queue = deque()
seen_entries = set()
placement = placements.get_placement_of_vertex(vertex)
partition = graph.get_outgoing_edge_partition_starting_at_vertex(
vertex, "Test")
entry = routing_paths.get_entry_on_coords_for_edge(
partition, placement.x, placement.y)
self.assertEqual(entry.incoming_processor, placement.p)
queue.append((placement.x, placement.y))
while len(queue) > 0:
x, y = queue.pop()
entry = routing_paths.get_entry_on_coords_for_edge(
partition, x, y)
self.assertIsNotNone(entry)
chip = machine.get_chip_at(x, y)
for p in entry.out_going_processors:
self.assertIsNotNone(chip.get_processor_with_id(p))
vertex_found = placements.get_vertex_on_processor(x, y, p)
vertices_reached.add(vertex_found)
seen_entries.add((x, y))
for link_id in entry.out_going_links:
link = chip.router.get_link(link_id)
self.assertIsNotNone(link)
dest_x, dest_y = link.destination_x, link.destination_y
if (dest_x, dest_y) not in seen_entries:
queue.append((dest_x, dest_y))
for vertex_to in vertices:
if vertex != vertex_to:
self.assertIn(vertex_to, vertices_reached)
def setUp(self):
self.machine = virtual_machine(8, 8)
self.mach_graph = MachineGraph("machine")
self.vertices = list()
self.vertex1 = T_MachineVertex(
0, 1, get_resources_used_by_atoms(0, 1, []), "First vertex")
self.vertex2 = T_MachineVertex(
1, 5, get_resources_used_by_atoms(1, 5, []), "Second vertex")
self.vertex3 = T_MachineVertex(
5, 10, get_resources_used_by_atoms(5, 10, []), "Third vertex")
self.vertex4 = T_MachineVertex(
10, 100, get_resources_used_by_atoms(10, 100, []),
"Fourth vertex")
self.vertices.append(self.vertex1)
self.mach_graph.add_vertex(self.vertex1)
self.vertices.append(self.vertex2)
self.mach_graph.add_vertex(self.vertex2)
self.vertices.append(self.vertex3)
self.mach_graph.add_vertex(self.vertex3)
self.vertices.append(self.vertex4)
self.mach_graph.add_vertex(self.vertex4)
self.edges = list()
self.plan_n_timesteps = 100
def test_that_6_lpgs_are_generated_2_on_each_eth_chip(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
default_params = {
'use_prefix': False,
'key_prefix': None,
'prefix_type': None,
'message_type': EIEIOType.KEY_32_BIT,
'right_shift': 0,
'payload_as_time_stamps': True,
'use_payload_prefix': True,
'payload_prefix': None,
'payload_right_shift': 0,
'number_of_packets_sent_per_time_step': 0,
'hostname': None,
'port': None,
'strip_sdp': None,
'board_address': None,
'tag': None,
'label': "test"
}
# data stores needed by algorithm
live_packet_gatherers = dict()
extended = dict(default_params)
extended.update({'partition_id': "EVENTS"})
default_params_holder = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder] = list()
# and special LPG on Ethernet connected chips
index = 1
chip_special = dict()
for chip in machine.ethernet_connected_chips:
extended['label'] = "test{}".format(index)
extended['board_address'] = chip.ip_address
default_params_holder2 = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder2] = list()
chip_special[(chip.x, chip.y)] = default_params_holder2
# run edge inserter that should go boom
edge_inserter = InsertLivePacketGatherersToGraphs()
lpg_verts_mapping = edge_inserter(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine,
machine_graph=graph,
application_graph=None,
graph_mapper=None)
self.assertEqual(len(lpg_verts_mapping[default_params_holder]), 3)
for eth_chip in chip_special:
params = chip_special[eth_chip]
self.assertEqual(len(lpg_verts_mapping[params]), 1)
vertex = lpg_verts_mapping[params][eth_chip]
self.assertEqual(eth_chip[0], list(vertex.constraints)[0].x)
self.assertEqual(eth_chip[1], list(vertex.constraints)[0].y)
def test_virtual_vertices_spreader():
""" Test that the placer works with a virtual vertex
"""
# Create a graph with a virtual vertex
machine_graph = MachineGraph("Test")
virtual_vertex = MachineSpiNNakerLinkVertex(
spinnaker_link_id=0, label="Virtual")
machine_graph.add_vertex(virtual_vertex)
# These vertices are fixed on 0, 0
misc_vertices = list()
for i in range(3):
misc_vertex = SimpleMachineVertex(
resources=ResourceContainer(), constraints=[
ChipAndCoreConstraint(0, 0)],
label="Fixed_0_0_{}".format(i))
machine_graph.add_vertex(misc_vertex)
misc_vertices.append(misc_vertex)
# These vertices are 1-1 connected to the virtual vertex
one_to_one_vertices = list()
for i in range(16):
one_to_one_vertex = SimpleMachineVertex(
resources=ResourceContainer(),
label="Vertex_{}".format(i))
machine_graph.add_vertex(one_to_one_vertex)
edge = MachineEdge(virtual_vertex, one_to_one_vertex)
machine_graph.add_edge(edge, "SPIKES")
one_to_one_vertices.append(one_to_one_vertex)
n_keys_map = DictBasedMachinePartitionNKeysMap()
partition = machine_graph.get_outgoing_edge_partition_starting_at_vertex(
virtual_vertex, "SPIKES")
n_keys_map.set_n_keys_for_partition(partition, 1)
# Get and extend the machine for the virtual chip
machine = virtual_machine(width=8, height=8)
extended_machine = MallocBasedChipIdAllocator()(machine, machine_graph)
# Do placements
placements = SpreaderPlacer()(
machine_graph, extended_machine, n_keys_map, plan_n_timesteps=1000)
# The virtual vertex should be on a virtual chip
placement = placements.get_placement_of_vertex(virtual_vertex)
assert machine.get_chip_at(placement.x, placement.y).virtual
# The 0, 0 vertices should be on 0, 0
for vertex in misc_vertices:
placement = placements.get_placement_of_vertex(vertex)
assert placement.x == placement.y == 0
# The other vertices should *not* be on a virtual chip
for vertex in one_to_one_vertices:
placement = placements.get_placement_of_vertex(vertex)
assert not machine.get_chip_at(placement.x, placement.y).virtual
def test_that_3_lpgs_are_generated_on_3_board_app_graph(self):
machine = virtual_machine(width=12, height=12)
app_graph = ApplicationGraph("Test")
graph = MachineGraph("Test", app_graph)
default_params = {
'use_prefix': False,
'key_prefix': None,
'prefix_type': None,
'message_type': EIEIOType.KEY_32_BIT,
'right_shift': 0,
'payload_as_time_stamps': True,
'use_payload_prefix': True,
'payload_prefix': None,
'payload_right_shift': 0,
'number_of_packets_sent_per_time_step': 0,
'hostname': None,
'port': None,
'strip_sdp': None,
'tag': None,
'label': "Test"}
# data stores needed by algorithm
live_packet_gatherers = dict()
default_params_holder = LivePacketGatherParameters(**default_params)
live_packet_gatherers[default_params_holder] = list()
# run edge inserter that should go boom
edge_inserter = InsertLivePacketGatherersToGraphs()
lpg_verts_mapping = edge_inserter(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine, machine_graph=graph, application_graph=app_graph)
self.assertEqual(len(lpg_verts_mapping[default_params_holder]), 3)
locs = list()
locs.append((0, 0))
locs.append((4, 8))
locs.append((8, 4))
for vertex in itervalues(lpg_verts_mapping[default_params_holder]):
x = list(vertex.constraints)[0].x
y = list(vertex.constraints)[0].y
key = (x, y)
locs.remove(key)
self.assertEqual(len(locs), 0)
verts = lpg_verts_mapping[default_params_holder].values()
for vertex in graph.vertices:
self.assertIn(vertex, verts)
app_verts = set()
for vertex in itervalues(lpg_verts_mapping[default_params_holder]):
app_vertex = vertex.app_vertex
self.assertNotEqual(app_vertex, None)
self.assertIsInstance(app_vertex, ApplicationVertex)
app_verts.add(app_vertex)
self.assertEqual(len(app_verts), 3)
def test_one_to_one():
""" Test normal 1-1 placement
"""
# Create a graph
machine_graph = MachineGraph("Test")
# Connect a set of vertices in a chain of length 3
one_to_one_chains = list()
for i in range(10):
last_vertex = None
chain = list()
for j in range(3):
vertex = SimpleMachineVertex(resources=ResourceContainer(),
label="Vertex_{}_{}".format(i, j))
machine_graph.add_vertex(vertex)
if last_vertex is not None:
edge = MachineEdge(last_vertex, vertex)
machine_graph.add_edge(edge, "SPIKES")
last_vertex = vertex
chain.append(vertex)
one_to_one_chains.append(chain)
# Connect a set of 20 vertices in a chain
too_many_vertices = list()
last_vertex = None
for i in range(20):
vertex = SimpleMachineVertex(resources=ResourceContainer(),
label="Vertex_{}".format(i))
machine_graph.add_vertex(vertex)
if last_vertex is not None:
edge = MachineEdge(last_vertex, vertex)
machine_graph.add_edge(edge, "SPIKES")
too_many_vertices.append(vertex)
last_vertex = vertex
# Do placements
machine = virtual_machine(width=8, height=8)
placements = OneToOnePlacer()(machine_graph,
machine,
plan_n_timesteps=1000)
# The 1-1 connected vertices should be on the same chip
for chain in one_to_one_chains:
first_placement = placements.get_placement_of_vertex(chain[0])
for i in range(1, 3):
placement = placements.get_placement_of_vertex(chain[i])
assert placement.x == first_placement.x
assert placement.y == first_placement.y
# The other vertices should be on more than one chip
too_many_chips = set()
for vertex in too_many_vertices:
placement = placements.get_placement_of_vertex(vertex)
too_many_chips.add((placement.x, placement.y))
assert len(too_many_chips) > 1
def test_routing(self):
graph = MachineGraph("Test")
set_config("Machine", "down_chips", "1,2:5,4:3,3")
machine = virtual_machine(8, 8)
placements = Placements()
vertices = list()
for chip in machine.chips:
for processor in chip.processors:
if not processor.is_monitor:
vertex = SimpleMachineVertex(resources=ResourceContainer())
graph.add_vertex(vertex)
placements.add_placement(
Placement(vertex, chip.x, chip.y,
processor.processor_id))
vertices.append(vertex)
for vertex in vertices:
graph.add_outgoing_edge_partition(
MulticastEdgePartition(identifier="Test", pre_vertex=vertex))
for vertex_to in vertices:
graph.add_edge(MachineEdge(vertex, vertex_to), "Test")
routing_paths = ner_route_traffic_aware(graph, machine, placements)
for vertex in vertices:
vertices_reached = set()
queue = deque()
seen_entries = set()
placement = placements.get_placement_of_vertex(vertex)
partition = graph.get_outgoing_edge_partition_starting_at_vertex(
vertex, "Test")
entry = routing_paths.get_entry_on_coords_for_edge(
partition, placement.x, placement.y)
self.assertEqual(entry.incoming_processor, placement.p)
queue.append((placement.x, placement.y))
while len(queue) > 0:
x, y = queue.pop()
entry = routing_paths.get_entry_on_coords_for_edge(
partition, x, y)
self.assertIsNotNone(entry)
chip = machine.get_chip_at(x, y)
for p in entry.processor_ids:
self.assertIsNotNone(chip.get_processor_with_id(p))
vertex_found = placements.get_vertex_on_processor(x, y, p)
vertices_reached.add(vertex_found)
seen_entries.add((x, y))
for link_id in entry.link_ids:
link = chip.router.get_link(link_id)
self.assertIsNotNone(link)
dest_x, dest_y = link.destination_x, link.destination_y
if (dest_x, dest_y) not in seen_entries:
queue.append((dest_x, dest_y))
for vertex_to in vertices:
self.assertIn(vertex_to, vertices_reached)
def test_none_have_app_vertex(self):
app_graph = ApplicationGraph("Test")
graph = MachineGraph("foo", app_graph)
app1 = SimpleTestVertex(12, "app1")
mach1 = SimpleMachineVertex("mach1", app_vertex=None)
mach2 = SimpleMachineVertex("mach2", app_vertex=None)
mach3 = SimpleMachineVertex("mach3", app_vertex=app1)
graph.add_vertices([mach1, mach2])
with self.assertRaises(PacmanInvalidParameterException):
graph.add_vertex(mach3)
def test_that_3_lpgs_are_generated_on_3_board(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
default_params = {
'use_prefix': False,
'key_prefix': None,
'prefix_type': None,
'message_type': EIEIOType.KEY_32_BIT,
'right_shift': 0,
'payload_as_time_stamps': True,
'use_payload_prefix': True,
'payload_prefix': None,
'payload_right_shift': 0,
'number_of_packets_sent_per_time_step': 0,
'hostname': None,
'port': None,
'strip_sdp': None,
'board_address': None,
'tag': None,
'label': "test"
}
# data stores needed by algorithm
live_packet_gatherers = dict()
extended = dict(default_params)
extended.update({'partition_id': "EVENTS"})
default_params_holder = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder] = list()
# run edge inserter that should go boom
edge_inserter = InsertLivePacketGatherersToGraphs()
lpg_verts_mapping = edge_inserter(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine,
machine_graph=graph,
application_graph=None,
graph_mapper=None)
self.assertEqual(len(lpg_verts_mapping[default_params_holder]), 3)
locs = list()
locs.append((0, 0))
locs.append((4, 8))
locs.append((8, 4))
for vertex in lpg_verts_mapping[default_params_holder].itervalues():
x = list(vertex.constraints)[0].x
y = list(vertex.constraints)[0].y
key = (x, y)
locs.remove(key)
self.assertEqual(len(locs), 0)
verts = lpg_verts_mapping[default_params_holder].values()
for vertex in graph.vertices:
self.assertIn(vertex, verts)
def _do_test(self, placer):
machine = virtual_machine(width=8, height=8)
graph = MachineGraph("Test")
vertices = [
SimpleMachineVertex(ResourceContainer(), label="v{}".format(i))
for i in range(100)
]
for vertex in vertices:
graph.add_vertex(vertex)
same_vertices = [
SimpleMachineVertex(ResourceContainer(), label="same{}".format(i))
for i in range(10)
]
random.seed(12345)
for vertex in same_vertices:
graph.add_vertex(vertex)
for _i in range(0, random.randint(1, 5)):
vertex.add_constraint(
SameChipAsConstraint(
vertices[random.randint(0, 99)]))
n_keys_map = DictBasedMachinePartitionNKeysMap()
inputs = {
"MemoryExtendedMachine": machine,
"MemoryMachine": machine,
"MemoryMachineGraph": graph,
"PlanNTimeSteps": None,
"MemoryMachinePartitionNKeysMap": n_keys_map
}
algorithms = [placer]
xml_paths = []
executor = PACMANAlgorithmExecutor(
algorithms, [], inputs, [], [], [], xml_paths)
executor.execute_mapping()
placements = executor.get_item("MemoryPlacements")
for same in same_vertices:
print("{0.vertex.label}, {0.x}, {0.y}, {0.p}: {1}".format(
placements.get_placement_of_vertex(same),
["{0.vertex.label}, {0.x}, {0.y}, {0.p}".format(
placements.get_placement_of_vertex(constraint.vertex))
for constraint in same.constraints]))
placement = placements.get_placement_of_vertex(same)
for constraint in same.constraints:
if isinstance(constraint, SameChipAsConstraint):
other_placement = placements.get_placement_of_vertex(
constraint.vertex)
self.assertTrue(
other_placement.x == placement.x and
other_placement.y == placement.y,
"Vertex was not placed on the same chip as requested")
def test_no_app_graph_no_app_vertex(self):
graph = MachineGraph("foo")
app1 = SimpleTestVertex(12, "app1")
mach1 = SimpleMachineVertex("mach1", app_vertex=app1)
mach2 = SimpleMachineVertex("mach2", app_vertex=None)
mach3 = SimpleMachineVertex("mach3", app_vertex=app1)
with self.assertRaises(PacmanInvalidParameterException):
graph.add_vertex(mach1)
graph.add_vertex(mach2)
with self.assertRaises(PacmanInvalidParameterException):
graph.add_vertex(mach3)
def _do_test(self, placer):
machine = virtual_machine(width=8, height=8)
graph = MachineGraph("Test")
plan_n_timesteps = 100
vertices = [
SimpleMachineVertex(ResourceContainer(),
label="v{}".format(i),
sdram_cost=20) for i in range(100)
]
for vertex in vertices:
graph.add_vertex(vertex)
same_vertices = [
SimpleMachineVertex(ResourceContainer(),
label="same{}".format(i),
sdram_cost=20) for i in range(10)
]
random.seed(12345)
sdram_edges = list()
for vertex in same_vertices:
graph.add_vertex(vertex)
graph.add_outgoing_edge_partition(
ConstantSDRAMMachinePartition(identifier="Test",
pre_vertex=vertex,
label="bacon"))
for _i in range(0, random.randint(1, 5)):
sdram_edge = SDRAMMachineEdge(vertex,
vertices[random.randint(0, 99)],
label="bacon",
app_edge=None)
sdram_edges.append(sdram_edge)
graph.add_edge(sdram_edge, "Test")
n_keys_map = DictBasedMachinePartitionNKeysMap()
inputs = {
"MemoryExtendedMachine": machine,
"MemoryMachine": machine,
"MemoryMachineGraph": graph,
"PlanNTimeSteps": plan_n_timesteps,
"MemoryMachinePartitionNKeysMap": n_keys_map
}
algorithms = [placer]
xml_paths = []
executor = PACMANAlgorithmExecutor(algorithms, [], inputs, [], [], [],
xml_paths)
executor.execute_mapping()
placements = executor.get_item("MemoryPlacements")
for edge in sdram_edges:
pre_place = placements.get_placement_of_vertex(edge.pre_vertex)
post_place = placements.get_placement_of_vertex(edge.post_vertex)
assert pre_place.x == post_place.x
assert pre_place.y == post_place.y
def test_place_vertex_too_big_with_vertex(self):
large_vertex = T_AppVertex(500, "Large vertex 500")
large_machine_vertex = large_vertex.create_machine_vertex(
0, 499, get_resources_used_by_atoms(0, 499, []))
self.graph.add_vertex(large_vertex)
self.graph = ApplicationGraph("Graph", [large_vertex])
self.graph_mapper = GraphMapper()
self.graph_mapper.add_vertices([large_machine_vertex], large_vertex)
self.bp = RadialPlacer(self.machine, self.graph)
self.graph = MachineGraph(vertices=[large_machine_vertex])
with self.assertRaises(PacmanPlaceException):
self.bp.place(self.graph, self.graph_mapper)
def graph_from_json(json_dict):
json_dict = json_to_object(json_dict)
graph = MachineGraph(json_dict.get("label"))
for j_vertex in json_dict["vertices"]:
graph.add_vertex(vertex_from_json(j_vertex, convert_constraints=False))
# Only do constraints when we have all the vertexes to link to
for j_vertex in json_dict["vertices"]:
vertex_add_contstraints_from_json(j_vertex, graph)
for j_edge in json_dict["edges"]:
edge = edge_from_json(j_edge, graph)
graph.add_edge(edge, "JSON_MOCK")
return graph
def test_fill_machine(self):
graph = MachineGraph("machine")
cores = sum(chip.n_user_processors for chip in self.machine.chips)
for i in range(cores): # 50 atoms per each processor on 20 chips
graph.add_vertex(
get_resourced_machine_vertex(0, 50, "vertex " + str(i)))
placements = connective_based_placer(graph, self.machine, 100)
self.assertEqual(len(placements), cores)
# One more vertex should be too many
graph.add_vertex(get_resourced_machine_vertex(0, 50, "toomany"))
with self.assertRaises(PacmanValueError):
connective_based_placer(graph, self.machine, 100)
def test_fill_machine(self):
vertices = list()
for i in range(99 * 17): # 50 atoms per each processor on 20 chips
vertices.append(
SimpleTestVertex(0, 50, get_resources_used_by_atoms(0, 50, []),
"SimpleMachineVertex " + str(i)))
self.graph = ApplicationGraph("Graph", vertices)
self.graph_mapper = GraphMapper()
self.graph_mapper.add_vertices(vertices)
self.bp = BasicPlacer(self.machine, self.graph)
self.graph = MachineGraph(vertices=vertices)
self.bp.place(self.graph, self.graph_mapper)
def _do_test(self, placer):
machine = virtual_machine(width=8, height=8)
graph = MachineGraph("Test")
vertices = [
SimpleMachineVertex(ResourceContainer(), label="v{}".format(i))
for i in range(100)
]
for vertex in vertices:
graph.add_vertex(vertex)
same_vertices = [
SimpleMachineVertex(ResourceContainer(), label="same{}".format(i))
for i in range(10)
]
random.seed(12345)
for vertex in same_vertices:
graph.add_vertex(vertex)
for _i in range(0, random.randint(1, 5)):
vertex.add_constraint(
SameChipAsConstraint(vertices[random.randint(0, 99)]))
n_keys_map = DictBasedMachinePartitionNKeysMap()
if placer == "ConnectiveBasedPlacer":
placements = connective_based_placer(graph, machine, None)
elif placer == "OneToOnePlacer":
placements = one_to_one_placer(graph, machine, None)
elif placer == "RadialPlacer":
placements = radial_placer(graph, machine, None)
elif placer == "SpreaderPlacer":
placements = spreader_placer(graph, machine, n_keys_map, None)
else:
raise NotImplementedError(placer)
for same in same_vertices:
print("{0.vertex.label}, {0.x}, {0.y}, {0.p}: {1}".format(
placements.get_placement_of_vertex(same), [
"{0.vertex.label}, {0.x}, {0.y}, {0.p}".format(
placements.get_placement_of_vertex(constraint.vertex))
for constraint in same.constraints
]))
placement = placements.get_placement_of_vertex(same)
for constraint in same.constraints:
if isinstance(constraint, SameChipAsConstraint):
other_placement = placements.get_placement_of_vertex(
constraint.vertex)
self.assertTrue(
other_placement.x == placement.x
and other_placement.y == placement.y,
"Vertex was not placed on the same chip as requested")