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)
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)
def __call__(self, partitioned_graph, machine):
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[
PlacerRadialPlacementFromChipConstraint,
TagAllocatorRequireIptagConstraint,
TagAllocatorRequireReverseIptagConstraint,
PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(
machine, self._generate_radial_chips(machine))
for vertex in ordered_subverts:
self._place_vertex(vertex, resource_tracker, machine, placements)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def test_get_placement_of_subvertex(self):
"""
checks the placements get placement method
:return:
"""
subv = list()
for i in range(5):
subv.append(PartitionedVertex(None, ""))
pl = list()
for i in range(4):
pl.append(Placement(subv[i], 0, 0, i))
pls = Placements(pl)
for i in range(4):
self.assertEqual(pls.get_placement_of_subvertex(subv[i]), pl[i])
def test_get_subvertex_on_processor(self):
"""
checks that from a placements object, you can get to the correct
subvertex using the get_subvertex_on_processor() method
:return:
"""
subv = list()
for i in range(5):
subv.append(PartitionedVertex(None, ""))
pl = list()
for i in range(4):
pl.append(Placement(subv[i], 0, 0, i))
pls = Placements(pl)
for i in range(4):
self.assertEqual(pls.get_subvertex_on_processor(0, 0, i), subv[i])
self.assertEqual(pls.get_placement_of_subvertex(subv[0]), pl[0])
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)
def __call__(self, partitioned_graph, machine):
""" Place a partitioned_graph so that each subvertex is placed on a\
core
:param partitioned_graph: The partitioned_graph to place
:type partitioned_graph:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:return: A set of placements
:rtype: :py:class:`pacman.model.placements.placements.Placements`
:raise pacman.exceptions.PacmanPlaceException: If something\
goes wrong with the placement
"""
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(machine)
for subvertex in ordered_subverts:
# Create and store a new placement anywhere on the board
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
subvertex.resources_required, subvertex.constraints)
placement = Placement(subvertex, x, y, p)
placements.add_placement(placement)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def __call__(self, partitioned_graph, machine):
""" Place a partitioned_graph so that each subvertex is placed on a\
core
:param partitioned_graph: The partitioned_graph to place
:type partitioned_graph:\
:py:class:`pacman.model.partitioned_graph.partitioned_graph.PartitionedGraph`
:return: A set of placements
:rtype: :py:class:`pacman.model.placements.placements.Placements`
:raise pacman.exceptions.PacmanPlaceException: If something\
goes wrong with the placement
"""
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[PlacerChipAndCoreConstraint],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
ordered_subverts = utility_calls.sort_objects_by_constraint_authority(
partitioned_graph.subvertices)
# Iterate over subvertices and generate placements
progress_bar = ProgressBar(len(ordered_subverts),
"Placing graph vertices")
resource_tracker = ResourceTracker(machine)
for subvertex in ordered_subverts:
# Create and store a new placement anywhere on the board
(x, y, p, _, _) = resource_tracker.allocate_constrained_resources(
subvertex.resources_required, subvertex.constraints)
placement = Placement(subvertex, x, y, p)
placements.add_placement(placement)
progress_bar.update()
progress_bar.end()
return {'placements': placements}
def test_memory_io():
vertex = MyVertex()
graph = MachineGraph("Test")
graph.add_vertex(vertex)
placements = Placements()
placements.add_placement(Placement(vertex, 0, 0, 1))
transceiver = _MockTransceiver()
temp = tempfile.mkdtemp()
print("ApplicationDataFolder = {}".format(temp))
inputs = {
"MemoryTransceiver": transceiver,
"MemoryMachineGraph": graph,
"MemoryPlacements": placements,
"IPAddress": "testing",
"ApplicationDataFolder": temp,
"APPID": 30
}
algorithms = ["WriteMemoryIOData"]
executor = PACMANAlgorithmExecutor(
algorithms, [],
inputs, [], [], [],
xml_paths=get_front_end_common_pacman_xml_paths())
executor.execute_mapping()
assert (vertex._test_tag == vertex._tag)
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 __call__(self, partitioned_graph, machine):
sorted_vertices = self._sort_vertices_for_one_to_one_connection(
partitioned_graph)
# check that the algorithm can handle the constraints
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=partitioned_graph.subvertices,
supported_constraints=[
PlacerRadialPlacementFromChipConstraint,
TagAllocatorRequireIptagConstraint,
TagAllocatorRequireReverseIptagConstraint,
PlacerChipAndCoreConstraint
],
abstract_constraint_type=AbstractPlacerConstraint)
placements = Placements()
self._do_allocation(sorted_vertices, placements, machine)
return {'placements': placements}
def convert_from_rig_placements(rig_placements, rig_allocations,
partitioned_graph):
placements = Placements()
for vertex_id in rig_placements:
vertex = partitioned_graph.get_subvertex_by_id(vertex_id)
if vertex is not None:
if isinstance(vertex, VirtualPartitionedVertex):
placements.add_placement(
Placement(vertex, vertex.virtual_chip_x,
vertex.virtual_chip_y, None))
else:
x, y = rig_placements[vertex_id]
p = rig_allocations[vertex_id]["cores"].start
placements.add_placement(Placement(vertex, x, y, p))
return placements
import logging
import os
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
for handler in logging.root.handlers:
handler.setFormatter(
logging.Formatter(fmt="%(asctime)-15s %(levelname)s: %(message)s",
datefmt="%Y-%m-%d %H:%M:%S"))
application_data = list()
binaries = ExecutableTargets()
iptags = list()
reverse_iptags = list()
buffered_tags = Tags()
buffered_placements = Placements()
routing_tables = MulticastRoutingTables()
# database params
socket_addresses = list()
reports_states = ReportState(False, False, False, False, False, False, False,
False, False, False)
machine_name = "192.168.240.253"
machine_version = 3
bmp_details = "None"
down_chips = "None"
down_cores = "None"
number_of_boards = 1
height = None
width = None
def __call__(self, placements, allocations, partitioned_graph,
extended_machine, constraints):
"""
:param placements:
:param allocations:
:param partitioned_graph:
:param extended_machine:
:param constraints:
:return:
"""
# load the json files
file_placements, core_allocations, constraints = \
self._load_json_files(placements, allocations, constraints)
# validate the json files against the schemas
self._validate_file_read_data(
file_placements, core_allocations, constraints)
# drop the type and allocations bit of core allocations
# (makes lower code simpler)
core_allocations = core_allocations['allocations']
memory_placements = Placements()
# process placements
for vertex_repr in file_placements:
subvertex = \
partitioned_graph.get_subvertex_with_repr(vertex_repr)
if vertex_repr not in core_allocations:
if subvertex is not None:
# virtual chip or tag chip
constraints_for_vertex = self._locate_constraints(
vertex_repr, constraints)
external_device_constraints = \
self._valid_constraints_for_external_device(
constraints_for_vertex)
if len(external_device_constraints) != 0:
# get data for virtual chip
route_constraint = \
external_device_constraints['end_point']
route_direction = constants.EDGES(
route_constraint['direction'].upper())
placement_constraint = \
external_device_constraints['placement']
coords = placement_constraint['location']
# locate virtual chip
link = extended_machine.get_chip_at(
coords[0], coords[1]).router.get_link(
route_direction.value)
destination_chip = extended_machine.get_chip_at(
link.destination_x, link.destination_y)
# create placement
placements.add_placement(Placement(
subvertex, destination_chip.x, destination_chip.y,
None))
else:
raise exceptions.PacmanConfigurationException(
"I don't recognise this pattern of constraints for"
" a vertex which does not have a placement")
else:
if subvertex is None:
raise exceptions.PacmanConfigurationException(
"Failed to locate the partitioned vertex in the "
"partitioned graph with label {}".format(vertex_repr))
else:
memory_placements.add_placement(
Placement(x=file_placements[vertex_repr][0],
y=file_placements[vertex_repr][1],
p=core_allocations[vertex_repr][0],
subvertex=subvertex))
# return the file format
return {"placements": memory_placements}
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")
def __call__(self, placements, allocations, partitioned_graph,
extended_machine, constraints):
"""
:param placements:
:param allocations:
:param partitioned_graph:
:param extended_machine:
:param constraints:
:return:
"""
# load the json files
file_placements, core_allocations, constraints = \
self._load_json_files(placements, allocations, constraints)
# validate the json files against the schemas
self._validate_file_read_data(file_placements, core_allocations,
constraints)
# drop the type and allocations bit of core allocations
# (makes lower code simpler)
core_allocations = core_allocations['allocations']
memory_placements = Placements()
# process placements
for vertex_id in file_placements:
subvertex = partitioned_graph.get_subvertex_by_id(vertex_id)
if vertex_id not in core_allocations:
if subvertex is not None:
# virtual chip or tag chip
constraints_for_vertex = self._locate_constraints(
vertex_id, constraints)
external_device_constraints = \
self._valid_constraints_for_external_device(
constraints_for_vertex)
if len(external_device_constraints) != 0:
# get data for virtual chip
route_constraint = \
external_device_constraints['end_point']
route_direction = constants.EDGES(
route_constraint['direction'].upper())
placement_constraint = \
external_device_constraints['placement']
coords = placement_constraint['location']
# locate virtual chip
link = extended_machine.get_chip_at(
coords[0],
coords[1]).router.get_link(route_direction.value)
destination_chip = extended_machine.get_chip_at(
link.destination_x, link.destination_y)
# create placement
placements.add_placement(
Placement(subvertex, destination_chip.x,
destination_chip.y, None))
else:
raise exceptions.PacmanConfigurationException(
"I don't recognise this pattern of constraints for"
" a vertex which does not have a placement")
else:
if subvertex is None:
raise exceptions.PacmanConfigurationException(
"Failed to locate the partitioned vertex in the "
"partitioned graph with label {}".format(vertex_id))
else:
memory_placements.add_placement(
Placement(x=file_placements[vertex_id][0],
y=file_placements[vertex_id][1],
p=core_allocations[vertex_id][0],
subvertex=subvertex))
# return the file format
return {"placements": memory_placements}
scamp_connection_data = "None"
boot_port_num = None
reset_machine_on_start_up = False
max_sdram_per_chip = None
router_tables = MulticastRoutingTables()
iptags = list()
reverse_iptags = list()
app_data_runtime_folder = os.path.abspath(
os.path.join(os.path.realpath("__file__"), os.pardir))
dsg_targets = dict()
exec_dse_on_host = True
dse_app_id = 31
buffered_tags = Tags()
buffered_placements = Placements()
wait_for_read_confirmation = True
database_socket_addresses = list()
database_file_path = r"None"
send_start_notification = True
executable_targets = ExecutableTargets()
app_id = 30
runtime = 100.0
time_scale_factor = 1
total_machine_timesteps = 100
time_threshold = 5
router_tables.add_routing_table(
ReloadRoutingTable.reload("picked_routing_table_for_0_0"))
import logging
import os
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
for handler in logging.root.handlers:
handler.setFormatter(
logging.Formatter(fmt="%(asctime)-15s %(levelname)s: %(message)s",
datefmt="%Y-%m-%d %H:%M:%S"))
application_data = list()
binaries = ExecutableTargets()
iptags = list()
reverse_iptags = list()
buffered_tags = Tags()
buffered_placements = Placements()
routing_tables = MulticastRoutingTables()
# database params
socket_addresses = list()
reports_states = ReportState(False, False, False, False, False, False, False,
False, False, False)
machine_name = "192.168.240.253"
machine_version = 3
bmp_details = "None"
down_chips = "None"
down_cores = "None"
number_of_boards = 1
height = None
width = None
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)
