def __call__(self, subgraph, n_keys_map, routing_paths):
# check that this algorithm supports the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=subgraph.subedges,
supported_constraints=[
KeyAllocatorFixedMaskConstraint,
KeyAllocatorFixedKeyAndMaskConstraint,
KeyAllocatorContiguousRangeContraint],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
routing_tables = MulticastRoutingTables()
# Get the partitioned edges grouped by those that require the same key
same_key_groups = \
routing_info_allocator_utilities.get_edge_groups(subgraph)
# Go through the groups and allocate keys
progress_bar = ProgressBar(len(same_key_groups),
"Allocating routing keys")
routing_infos = RoutingInfo()
for group in same_key_groups:
# Check how many keys are needed for the edges of the group
edge_n_keys = None
for edge in group:
n_keys = n_keys_map.n_keys_for_partitioned_edge(edge)
if edge_n_keys is None:
edge_n_keys = n_keys
elif edge_n_keys != n_keys:
raise PacmanRouteInfoAllocationException(
"Two edges require the same keys but request a"
" different number of keys")
# Get any fixed keys and masks from the group and attempt to
# allocate them
keys_and_masks = routing_info_allocator_utilities.\
get_fixed_key_and_mask(group)
fixed_mask, fields = \
routing_info_allocator_utilities.get_fixed_mask(group)
if keys_and_masks is not None:
self._allocate_fixed_keys_and_masks(keys_and_masks, fixed_mask)
else:
keys_and_masks = self._allocate_keys_and_masks(
fixed_mask, fields, edge_n_keys)
# Allocate the routing information
for edge in group:
subedge_info = SubedgeRoutingInfo(keys_and_masks, edge)
routing_infos.add_subedge_info(subedge_info)
# update routing tables with entries
routing_info_allocator_utilities.add_routing_key_entries(
routing_paths, subedge_info, edge, routing_tables)
progress_bar.update()
progress_bar.end()
return {'routing_infos': routing_infos,
'routing_tables': routing_tables}
def test_full_machine_routing(self):
placements = Placements()
self.placement1 = Placement(x=1, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=1, y=0, p=3, subvertex=self.subvert2)
subvertices = list()
for i in range(4 * 17): #51 atoms per each processor on 20 chips
subvertices.append(PartitionedVertex(
0, 50, get_resources_used_by_atoms(0, 50, []),
"Subvertex " + str(i)))
subedges = list()
for i in range(len(subvertices)):
subedges.append(AbstractPartitionedEdge(
subvertices[i], subvertices[(i + 1)%len(subvertices)]))
subgraph = PartitionedGraph("Subgraph", subvertices, subedges)
p = 1
x = 0
y = 0
for subvert in subvertices:
placements.add_placement(Placement(subvert, x, y, p))
p = (p + 1) % 18
if p == 0:
p += 1
y += 1
if y == 2:
y = 0
x += 1
routing_info = RoutingInfo()
subedge_routing_info = list()
for i in range(len(subedges)):
subedge_routing_info.append(SubedgeRoutingInfo(
subedges[i], i<<11, constants.DEFAULT_MASK))
for subedge_info in subedge_routing_info:
routing_info.add_subedge_info(subedge_info)
self.set_up_4_node_board()
dijkstra_router = BasicDijkstraRouting()
routing_tables = dijkstra_router.route(
machine=self.machine, placements=placements,
partitioned_graph=subgraph,
routing_info_allocation=routing_info)
for entry in routing_tables.routing_tables:
print entry.x, entry.y
for routing_entry in entry.multicast_routing_entries:
print "\t\tProcessor_ids:{}, Link_ids:{}".format(
routing_entry.processor_ids,
routing_entry.link_ids)
class MyTestCase(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, get_resources_used_by_atoms(0, 10, []))
self.subvert2 = PartitionedVertex(
0, 5, 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)
# 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
flops = 1000
(e, ne, n, w, sw, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
_sdram = SDRAM(128 * (2 ** 20))
ip = "192.162.240.253"
chips = list()
for x in range(10):
for y in range(10):
links = list()
links.append(Link(x, y, 0, (x + 1) % 10, y, n, n))
links.append(Link(x, y, 1, (x + 1) % 10, (y + 1) % 10, s, s))
links.append(Link(x, y, 2, x, (y + 1) % 10, n, n))
links.append(Link(x, y, 3, (x - 1) % 10, y, s, s))
links.append(Link(x, y, 4, (x - 1) % 10, (y - 1) % 10, n, n))
links.append(Link(x, y, 5, x, (y - 1) % 10, s, s))
r = Router(links, False, 100, 1024)
chips.append(Chip(x, y, processors, r, _sdram, ip))
self.machine = Machine(chips)
@unittest.skip("demonstrating skipping")
def set_up_4_node_board(self):
flops = 1000
(e, ne, n, w, sw, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
_sdram = SDRAM(128 * (2 ** 20))
ip = "192.162.240.253"
chips = list()
for x in range(2):
for y in range(2):
links = list()
links.append(Link(x, y, 0, (x + 1) % 2, y, n, n))
links.append(Link(x, y, 1, (x + 1) % 2, (y + 1) % 2, s, s))
links.append(Link(x, y, 2, x, (y + 1) % 2, n, n))
links.append(Link(x, y, 3, (x - 1) % 2, y, s, s))
links.append(Link(x, y, 4, (x - 1) % 2, (y - 1) % 2, n, n))
links.append(Link(x, y, 5, x, (y - 1) % 2, s, s))
r = Router(links, False, 100, 1024)
chips.append(Chip(x, y, processors, r, _sdram, ip))
self.machine = Machine(chips)
@unittest.skip("demonstrating skipping")
def test_new_basic_router(self):
dijkstra_router = BasicDijkstraRouting()
self.assertEqual(dijkstra_router._k, 1)
self.assertEqual(dijkstra_router._l, 0)
self.assertEqual(dijkstra_router._m, 0)
self.assertEqual(dijkstra_router._bw_per_route_entry,
dijkstra_router.BW_PER_ROUTE_ENTRY)
self.assertEqual(dijkstra_router._max_bw, dijkstra_router.MAX_BW)
@unittest.skip("demonstrating skipping")
def test_run_basic_routing_off_chip_custom_100_node_machine(self):
dijkstra_router = BasicDijkstraRouting()
routing_tables = dijkstra_router.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
for entry in routing_tables.routing_tables:
print entry.x, entry.y
for routing_entry in entry.multicast_routing_entries:
print "\t\tProcessor_ids:{}, Link_ids:{}".format(
routing_entry.processor_ids,
routing_entry.link_ids)
@unittest.skip("demonstrating skipping")
def test_run_basic_routing_off_chip_custom_4_node_machine(self):
self.set_up_4_node_board()
dijkstra_router = BasicDijkstraRouting()
routing_tables = dijkstra_router.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
for entry in routing_tables.routing_tables:
print entry.x, entry.y
for routing_entry in entry.multicast_routing_entries:
print "\t\tProcessor_ids:{}, Link_ids:{}".format(
routing_entry.processor_ids,
routing_entry.link_ids)
@unittest.skip("demonstrating skipping")
def test_bad_machine_setup(self):
# create machine
flops = 1000
(e, ne, n, w, sw, s) = range(6)
processors = list()
for i in range(18):
processors.append(Processor(i, flops))
links = list()
links.append(Link(0, 0, 0, 0, 1, s, s))
_sdram = SDRAM(128 * (2 ** 20))
links = list()
links.append(Link(0, 0, 0, 1, 1, n, n))
links.append(Link(0, 1, 1, 1, 0, s, s))
links.append(Link(1, 1, 2, 0, 0, e, e))
links.append(Link(1, 0, 3, 0, 1, w, w))
r = Router(links, False, 100, 1024)
ip = "192.162.240.253"
chips = list()
for x in range(5):
for y in range(5):
chips.append(Chip(x, y, processors, r, _sdram, ip))
self.machine = Machine(chips)
dijkstra_router = BasicDijkstraRouting()
with self.assertRaises(PacmanRoutingException):
dijkstra_router.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_routing_on_chip_custom_4_node_machine(self):
self.placements = Placements()
self.placement1 = Placement(x=1, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=1, 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)
self.set_up_4_node_board()
dijkstra_router = BasicDijkstraRouting()
routing_tables = dijkstra_router.route(
machine=self.machine, placements=self.placements,
partitioned_graph=self.subgraph,
routing_info_allocation=self.routing_info)
for entry in routing_tables.routing_tables:
print entry.x, entry.y
for routing_entry in entry.multicast_routing_entries:
print "\t\tProcessor_ids:{}, Link_ids:{}".format(
routing_entry.processor_ids,
routing_entry.link_ids)
@unittest.skip("demonstrating skipping")
def test_full_machine_routing(self):
placements = Placements()
self.placement1 = Placement(x=1, y=0, p=2, subvertex=self.subvert1)
self.placement2 = Placement(x=1, y=0, p=3, subvertex=self.subvert2)
subvertices = list()
for i in range(4 * 17): #51 atoms per each processor on 20 chips
subvertices.append(PartitionedVertex(
0, 50, get_resources_used_by_atoms(0, 50, []),
"Subvertex " + str(i)))
subedges = list()
for i in range(len(subvertices)):
subedges.append(AbstractPartitionedEdge(
subvertices[i], subvertices[(i + 1)%len(subvertices)]))
subgraph = PartitionedGraph("Subgraph", subvertices, subedges)
p = 1
x = 0
y = 0
for subvert in subvertices:
placements.add_placement(Placement(subvert, x, y, p))
p = (p + 1) % 18
if p == 0:
p += 1
y += 1
if y == 2:
y = 0
x += 1
routing_info = RoutingInfo()
subedge_routing_info = list()
for i in range(len(subedges)):
subedge_routing_info.append(SubedgeRoutingInfo(
subedges[i], i<<11, constants.DEFAULT_MASK))
for subedge_info in subedge_routing_info:
routing_info.add_subedge_info(subedge_info)
self.set_up_4_node_board()
dijkstra_router = BasicDijkstraRouting()
routing_tables = dijkstra_router.route(
machine=self.machine, placements=placements,
partitioned_graph=subgraph,
routing_info_allocation=routing_info)
for entry in routing_tables.routing_tables:
print entry.x, entry.y
for routing_entry in entry.multicast_routing_entries:
print "\t\tProcessor_ids:{}, Link_ids:{}".format(
routing_entry.processor_ids,
routing_entry.link_ids)
@unittest.skip("demonstrating skipping")
def test_routing_to_other_machine(self):
self.assertEqual(True, False, "Test not implemented yet")
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)
def __call__(self, subgraph, placements, n_keys_map, routing_paths):
"""
Allocates routing information to the partitioned edges in a\
partitioned graph
:param subgraph: The partitioned graph to allocate the routing info for
:type subgraph:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:param placements: The placements of the subvertices
:type placements:\
:py:class:`pacman.model.placements.placements.Placements`
:param n_keys_map: A map between the partitioned edges and the number\
of keys required by the edges
:type n_keys_map:\
:py:class:`pacman.model.routing_info.abstract_partitioned_edge_n_keys_map.AbstractPartitionedEdgeNKeysMap`
:param routing_paths: the paths each partitioned edge takes to get\
from source to destination.
:type routing_paths:
:py:class:`pacman.model.routing_paths.multicast_routing_paths.MulticastRoutingPaths
:return: The routing information
:rtype: :py:class:`pacman.model.routing_info.routing_info.RoutingInfo`,
:py:class:`pacman.model.routing_tables.multicast_routing_table.MulticastRoutingTable
:raise pacman.exceptions.PacmanRouteInfoAllocationException: If\
something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitioned_edges
supported_constraints = [RequiresRoutingInfoPartitionedVertex]
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=subgraph.subedges,
supported_constraints=supported_constraints,
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each subedge and create keys from its placement
progress_bar = ProgressBar(len(subgraph.subvertices),
"Allocating routing keys")
routing_infos = RoutingInfo()
routing_tables = MulticastRoutingTables()
for subvert in subgraph.subvertices:
out_going_subedges = subgraph.outgoing_subedges_from_subvertex(
subvert)
for out_going_subedge in out_going_subedges:
n_keys = n_keys_map.n_keys_for_partitioned_edge(
out_going_subedge)
if n_keys > MAX_KEYS_SUPPORTED:
raise PacmanRouteInfoAllocationException(
"This routing info allocator can only support up to {}"
" keys for any given subedge; cannot therefore"
" allocate keys to {}, which is requesting {} keys"
.format(MAX_KEYS_SUPPORTED, out_going_subedge, n_keys))
placement = placements.get_placement_of_subvertex(subvert)
if placement is not None:
key = self._get_key_from_placement(placement)
keys_and_masks = list([BaseKeyAndMask(base_key=key,
mask=MASK)])
subedge_routing_info = SubedgeRoutingInfo(
keys_and_masks, out_going_subedge)
routing_infos.add_subedge_info(subedge_routing_info)
else:
raise PacmanRouteInfoAllocationException(
"This subvertex '{}' has no placement! this should "
"never occur, please fix and try again."
.format(subvert))
# update routing tables with entries
routing_info_allocator_utilities.add_routing_key_entries(
routing_paths, subedge_routing_info, out_going_subedge,
routing_tables)
progress_bar.update()
progress_bar.end()
return {'routing_infos': routing_infos,
'routing_tables': routing_tables}
