def test_partition_with_fixed_atom_constraints(self): """ test a partitioning with a graph with fixed atom constraint """ # Create a 2x2 machine with 10 cores per chip (so 40 cores), # but 1 off 2 per chip (so 19 per chip) n_cores_per_chip = 10 sdram_per_chip = (n_cores_per_chip * 2) - 1 set_config("Machine", "max_sdram_allowed_per_chip", sdram_per_chip) machine = virtual_machine(width=2, height=2, n_cpus_per_chip=n_cores_per_chip) # Create a vertex where each atom requires 1MB (default) of SDRAM # but which can't be subdivided lower than 2 atoms per core. # The vertex has 1 atom per MB of SDRAM, and so would fit but will # be disallowed by the fixed atoms per core constraint vertex = SimpleTestVertex(sdram_per_chip * machine.n_chips, max_atoms_per_core=2, constraints=[FixedVertexAtomsConstraint(2)]) vertex.splitter = SplitterSliceLegacy() app_graph = ApplicationGraph("Test") app_graph.add_vertex(vertex) # Do the partitioning - this should result in an error with self.assertRaises(PacmanException): splitter_partitioner(app_graph, machine, 3000)
def test_routing(self): graph = MachineGraph("Test") set_config("Machine", "down_chips", "1,2:5,4:3,3") machine = virtual_machine(8, 8) placements = Placements() vertices = list() for chip in machine.chips: for processor in chip.processors: if not processor.is_monitor: vertex = SimpleMachineVertex(resources=ResourceContainer()) graph.add_vertex(vertex) placements.add_placement( Placement(vertex, chip.x, chip.y, processor.processor_id)) vertices.append(vertex) for vertex in vertices: graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="Test", pre_vertex=vertex)) for vertex_to in vertices: graph.add_edge(MachineEdge(vertex, vertex_to), "Test") routing_paths = ner_route_traffic_aware(graph, machine, placements) for vertex in vertices: vertices_reached = set() queue = deque() seen_entries = set() placement = placements.get_placement_of_vertex(vertex) partition = graph.get_outgoing_edge_partition_starting_at_vertex( vertex, "Test") entry = routing_paths.get_entry_on_coords_for_edge( partition, placement.x, placement.y) self.assertEqual(entry.incoming_processor, placement.p) queue.append((placement.x, placement.y)) while len(queue) > 0: x, y = queue.pop() entry = routing_paths.get_entry_on_coords_for_edge( partition, x, y) self.assertIsNotNone(entry) chip = machine.get_chip_at(x, y) for p in entry.processor_ids: self.assertIsNotNone(chip.get_processor_with_id(p)) vertex_found = placements.get_vertex_on_processor(x, y, p) vertices_reached.add(vertex_found) seen_entries.add((x, y)) for link_id in entry.link_ids: link = chip.router.get_link(link_id) self.assertIsNotNone(link) dest_x, dest_y = link.destination_x, link.destination_y if (dest_x, dest_y) not in seen_entries: queue.append((dest_x, dest_y)) for vertex_to in vertices: self.assertIn(vertex_to, vertices_reached)
def test_big(self): set_config("Mapping", "router_table_compress_as_far_as_possible", True) class_file = sys.modules[self.__module__].__file__ path = os.path.dirname(os.path.abspath(class_file)) j_router = os.path.join(path, "malloc_hard_routing_tables.json.gz") original_tables = from_json(j_router) mundy_compressor = OrderedCoveringCompressor() pre_compressor = UnorderedPairCompressor() start = time.time() mundy_tables = mundy_compressor(original_tables, True) mundy_time = time.time() pre_tables = pre_compressor(original_tables, True) pre_time = time.time() both_tables = mundy_compressor(pre_tables, True) both_time = time.time() for original in original_tables: org_routes = set() for entry in original.multicast_routing_entries: org_routes.add(entry.spinnaker_route) mundy = mundy_tables.get_routing_table_for_chip( original.x, original.y) mundy_routes = set() for entry in mundy.multicast_routing_entries: mundy_routes.add(entry.spinnaker_route) compare_tables(original, mundy) pre = pre_tables.get_routing_table_for_chip(original.x, original.y) pre_routes = set() for entry in pre.multicast_routing_entries: pre_routes.add(entry.spinnaker_route) compare_tables(original, pre) both = both_tables.get_routing_table_for_chip( original.x, original.y) both_routes = set() for entry in both.multicast_routing_entries: both_routes.add(entry.spinnaker_route) compare_tables(original, both) print("org:", original.number_of_entries, len(org_routes), "mundy:", mundy.number_of_entries, len(mundy_routes), "pre:", pre.number_of_entries, len(pre_routes), "both:", both.number_of_entries, len(both_routes)) print("Mundy", mundy_time - start) print("Unordered", pre_time - mundy_time) print("Mundy after Unordered", both_time - pre_time)
def test_all_working(width, height, with_down_links, with_down_chips): unittest_setup() temp_machine = virtual_machine(width=width, height=height) down_links = None if with_down_links: down_links = set() for ethernet_chip in temp_machine.ethernet_connected_chips: down_links.add((ethernet_chip.x + 1, ethernet_chip.y, 5)) down_links.add((ethernet_chip.x, ethernet_chip.y + 1, 3)) down_str = ":".join([f"{x},{y},{link}" for x, y, link in down_links]) set_config("Machine", "down_links", down_str) down_chips = None if with_down_chips: down_chips = set( (ethernet_chip.x + 1, ethernet_chip.y + 1) for ethernet_chip in temp_machine.ethernet_connected_chips) down_str = ":".join([f"{x},{y}" for x, y in down_chips]) set_config("Machine", "down_chips", down_str) _check_setup(width, height)
def setUp(self): self.original_tables = MulticastRoutingTables() original_table = UnCompressedMulticastRoutingTable(x=0, y=0) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0101, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1000, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1001, 0b1111, [0], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1110, 0b1111, [4], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b1100, 0b1111, [1, 2], [], False)) original_table.add_multicast_routing_entry( MulticastRoutingEntry(0b0010, 0b1011, [4, 5], [], False)) self.original_tables.add_routing_table(original_table) unittest_setup() set_config("Mapping", "router_table_compress_as_far_as_possible", True)
def hacked_receive_chip_info(self, scp_read_chip_info_response): chip_info = scp_read_chip_info_response.chip_info self._chip_info[chip_info.x, chip_info.y] = chip_info # Hack to test ignores if (chip_info.x == 8 and chip_info.y == 4): # hack the config to include an actual ip address used set_config( "Machine", "down_cores", f"3,0,-4:99,99,2:2,2,-19:3,3,4,127.0.0.1:" f"2,2,-10,{chip_info.ethernet_ip_address}:" f"2,2,-9,{chip_info.ethernet_ip_address}:" f"2,2,4,{chip_info.ethernet_ip_address}") set_config( "Machine", "down_chips", f"6,7:3,3,127.0.0.1:" f"3,3,{chip_info.ethernet_ip_address}") set_config( "Machine", "down_links", f"3,3,4,127.0.0.1:5,5,2:" f"4,4,1,{chip_info.ethernet_ip_address}")
json_obj = to_json(bad) # dump to json file with open("routing_tables_zoned_bad1.json", "w") as f: json.dump(json_obj, f) json_obj = to_json(good) # dump to json file with open("routing_tables_zoned_2000.json", "w") as f: json.dump(json_obj, f) original_tables = bad MUNDY = True PRE = True PAIR = True # Hack to stop it throwing a wobly for too many entries Machine.ROUTER_ENTRIES = 50000 set_config("Mapping", "router_table_compress_as_far_as_possible", True) if MUNDY: start = time.time() mundy_tables = ordered_covering_compressor(original_tables) mundy_time = time.time() if PRE: pre_tables = pair_compressor(original_tables, ordered=False) pre_time = time.time() if MUNDY and PRE: both_tables = ordered_covering_compressor(pre_tables) both_time = time.time() if PAIR: pair_tables = pair_compressor(original_tables) pair_time = time.time() for original in original_tables:
def test_unreachable(): unittest_setup() set_config("Machine", "down_chips", "0,2:1,3:1,4") with pytest.raises(PacmanRoutingException): _check_setup(8, 8)
def setUp(self): unittest_setup() set_config("Mapping", "router_table_compress_as_far_as_possible", True)