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 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.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:
if vertex != vertex_to:
self.assertIn(vertex_to, vertices_reached)
def test_new_router_set_non_default_routing_algorithm(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertEqual(self.routing._graph_mappings, None)
def test_new_router(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertIsInstance(self.routing._router_algorithm,
BasicDijkstraRouting)
self.assertEqual(self.routing._graph_mappings, None)
def test_new_router_set_non_default_routing_algorithm(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertEqual(self.routing._graph_to_subgraph_mappings, None)
def test_new_router(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertIsInstance(self.routing._router_algorithm,
BasicDijkstraRouting)
self.assertEqual(self.routing._graph_to_subgraph_mappings, None)
def test_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
def _do_routing(fake_placements, fake_graph, fake_machine):
""" executes the routing
:param fake_placements: the fake placements
:param fake_graph: the fake graph
:param fake_machine: the fake machine
:return: the routes
"""
# route as if using multicast
router = BasicDijkstraRouting()
return router(placements=fake_placements,
machine=fake_machine,
machine_graph=fake_graph,
use_progress_bar=False)
def test_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=0, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
def _do_dynamic_routing(
self, fixed_route_tables, placements, ethernet_connected_chip,
destination_class, machine, board_version):
""" Uses a router to route fixed routes
:param fixed_route_tables: fixed route tables entry holder
:param placements: placements
:param ethernet_connected_chip: the chip to consider for this routing
:param destination_class: the class at the Ethernet connected chip\
for receiving all these routes.
:param machine: SpiNNMachine instance
:param board_version: The version of the machine
:rtype: None
"""
graph = MachineGraph(label="routing graph")
fake_placements = Placements()
# build fake setup for the routing
eth_x = ethernet_connected_chip.x
eth_y = ethernet_connected_chip.y
down_links = set()
for (chip_x, chip_y) in machine.get_chips_on_board(
ethernet_connected_chip):
vertex = RoutingMachineVertex()
graph.add_vertex(vertex)
rel_x = chip_x - eth_x
if rel_x < 0:
rel_x += machine.max_chip_x + 1
rel_y = chip_y - eth_y
if rel_y < 0:
rel_y += machine.max_chip_y + 1
free_processor = 0
while ((free_processor < machine.MAX_CORES_PER_CHIP) and
fake_placements.is_processor_occupied(
self.FAKE_ETHERNET_CHIP_X,
y=self.FAKE_ETHERNET_CHIP_Y,
p=free_processor)):
free_processor += 1
fake_placements.add_placement(Placement(
x=rel_x, y=rel_y, p=free_processor, vertex=vertex))
down_links.update({
(rel_x, rel_y, link) for link in range(
Router.MAX_LINKS_PER_ROUTER)
if not machine.is_link_at(chip_x, chip_y, link)})
# Create a fake machine consisting of only the one board that
# the routes should go over
fake_machine = machine
if (board_version in machine.BOARD_VERSION_FOR_48_CHIPS and
(machine.max_chip_x > machine.MAX_CHIP_X_ID_ON_ONE_BOARD or
machine.max_chip_y > machine.MAX_CHIP_Y_ID_ON_ONE_BOARD)):
down_chips = {
(x, y) for x, y in zip(
range(machine.SIZE_X_OF_ONE_BOARD),
range(machine.SIZE_Y_OF_ONE_BOARD))
if not machine.is_chip_at(
(x + eth_x) % (machine.max_chip_x + 1),
(y + eth_y) % (machine.max_chip_y + 1))}
# build a fake machine which is just one board but with the missing
# bits of the real board
fake_machine = VirtualMachine(
machine.SIZE_X_OF_ONE_BOARD, machine.SIZE_Y_OF_ONE_BOARD,
False, down_chips=down_chips, down_links=down_links)
# build destination
verts = graph.vertices
vertex_dest = RoutingMachineVertex()
graph.add_vertex(vertex_dest)
destination_processor = self._locate_destination(
ethernet_chip_x=ethernet_connected_chip.x,
ethernet_chip_y=ethernet_connected_chip.y,
destination_class=destination_class,
placements=placements)
fake_placements.add_placement(Placement(
x=self.FAKE_ETHERNET_CHIP_X, y=self.FAKE_ETHERNET_CHIP_Y,
p=destination_processor, vertex=vertex_dest))
# deal with edges
for vertex in verts:
graph.add_edge(
MachineEdge(pre_vertex=vertex, post_vertex=vertex_dest),
self.FAKE_ROUTING_PARTITION)
# route as if using multicast
router = BasicDijkstraRouting()
routing_tables_by_partition = router(
placements=fake_placements, machine=fake_machine,
machine_graph=graph, use_progress_bar=False)
# convert to fixed route entries
for (chip_x, chip_y) in routing_tables_by_partition.get_routers():
mc_entries = routing_tables_by_partition.get_entries_for_router(
chip_x, chip_y)
# only want the first entry, as that will all be the same.
mc_entry = next(itervalues(mc_entries))
fixed_route_entry = FixedRouteEntry(
link_ids=mc_entry.out_going_links,
processor_ids=mc_entry.out_going_processors)
x = (chip_x + eth_x) % (machine.max_chip_x + 1)
y = (chip_y + eth_y) % (machine.max_chip_y + 1)
key = (x, y)
if key in fixed_route_tables:
raise PacmanAlreadyExistsException(
"fixed route entry", str(key))
fixed_route_tables[key] = fixed_route_entry
class TestRouter(unittest.TestCase):
def setUp(self):
#sort out graph
self.vert1 = Vertex(10, "New AbstractConstrainedVertex 1")
self.vert2 = Vertex(5, "New AbstractConstrainedVertex 2")
self.edge1 = AbstractPartitionableEdge(self.vert1, self.vert2, "First edge")
self.verts = [self.vert1, self.vert2]
self.edges = [self.edge1]
self.graph = PartitionableGraph("Graph", self.verts, self.edges)
#sort out subgraph
self.subgraph = PartitionedGraph()
self.subvert1 = PartitionedVertex(
0, 10, self.vert1.get_resources_used_by_atoms(0, 10, []))
self.subvert2 = PartitionedVertex(
0, 5, self.vert2.get_resources_used_by_atoms(0, 10, []))
self.subedge = AbstractPartitionedEdge(self.subvert1, self.subvert2)
self.subgraph.add_subvertex(self.subvert1)
self.subgraph.add_subvertex(self.subvert2)
self.subgraph.add_subedge(self.subedge)
@unittest.skip("demonstrating skipping")
def test_router_with_same_chip_route(self):
#sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=0, p=3, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_neighbour_chip(self):
#sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=1, y=1, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_0(self):
#sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=2, y=0, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_1(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=2, y=2, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_2(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=2, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_3(self):
self.placements = Placements()
self.placement1 = Placement(x=2, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=0, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_4(self):
self.placements = Placements()
self.placement1 = Placement(x=2, y=2, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=0, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=0, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_not_default(self):
#sort out placements
self.placements = Placements()
self.placement1 = Placement(x=2, y=1, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=0, y=0, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_multi_hop_route_across_board(self):
#sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=8, y=7, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_new_router(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertIsInstance(self.routing._router_algorithm,
BasicDijkstraRouting)
self.assertEqual(self.routing._graph_to_subgraph_mappings, None)
@unittest.skip("demonstrating skipping")
def test_new_router_set_non_default_routing_algorithm(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertEqual(self.routing._graph_to_subgraph_mappings, None)
@unittest.skip("demonstrating skipping")
def test_run_router(self):
#sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=1, y=1, p=2, subvertex=self.subvert2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
#sort out routing infos
self.routing_info = RoutingInfo()
self.subedge_routing_info1 = \
SubedgeRoutingInfo(key=2 << 11, mask=constants.DEFAULT_MASK,
subedge=self.subedge)
self.routing_info.add_subedge_info(self.subedge_routing_info1)
#create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
class TestRouter(unittest.TestCase):
def setUp(self):
# sort out graph
self.vert1 = Vertex(10, "New AbstractConstrainedVertex 1")
self.vert2 = Vertex(5, "New AbstractConstrainedVertex 2")
self.edge1 = ApplicationEdge(self.vert1, self.vert2, "First edge")
self.verts = [self.vert1, self.vert2]
self.edges = [self.edge1]
self.graph = ApplicationGraph("Graph", self.verts, self.edges)
# sort out graph
self.graph = MachineGraph()
self.vertex1 = SimpleMachineVertex(
0, 10, self.vert1.get_resources_used_by_atoms(0, 10, []))
self.vertex2 = SimpleMachineVertex(
0, 5, self.vert2.get_resources_used_by_atoms(0, 10, []))
self.edge = MachineEdge(self.vertex1, self.vertex2)
self.graph.add_vertex(self.vertex1)
self.graph.add_vertex(self.vertex2)
self.graph.add_edge(self.edge, "TEST")
@unittest.skip("demonstrating skipping")
def test_router_with_same_chip_route(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=3, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_neighbour_chip(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=1, y=1, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_0(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=2, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_1(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=2, y=2, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_2(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=2, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_3(self):
self.placements = Placements()
self.placement1 = Placement(x=2, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_4(self):
self.placements = Placements()
self.placement1 = Placement(x=2, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_not_default(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=2, y=1, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_multi_hop_route_across_board(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=8, y=7, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_new_router(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertIsInstance(self.routing._router_algorithm,
BasicDijkstraRouting)
self.assertEqual(self.routing._graph_mappings, None)
@unittest.skip("demonstrating skipping")
def test_new_router_set_non_default_routing_algorithm(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertEqual(self.routing._graph_mappings, None)
@unittest.skip("demonstrating skipping")
def test_run_router(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=1, y=1, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
