def test_add_high_chip_with_down(self): down_chips = set() down_chips.add((1, 1)) vm = VirtualMachine(2, 2, down_chips=down_chips) self.assertEqual(3, vm.n_chips) _chip = self._create_chip(2, 2) vm.add_chip(_chip) self.assertEqual(vm.max_chip_x, 2) self.assertEqual(vm.max_chip_y, 2) self.assertEqual(4, vm.n_chips) self.assertTrue(vm.is_chip_at(2, 2)) _good = vm.get_chip_at(2, 2) self.assertEqual(_chip, _good) _bad = vm.get_chip_at(2, 1) self.assertIsNone(_bad) _down = vm.get_chip_at(1, 1) self.assertIsNone(_down) count = 0 for _chip in vm.chips: count += 1 self.assertTrue(4, count)
def test_deallocation_of_resources(self): machine = VirtualMachine( width=2, height=2, n_cpus_per_chip=18, with_monitors=True) chip_sdram = machine.get_chip_at(1, 1).sdram.size res_sdram = 12345 tracker = ResourceTracker(machine, plan_n_timesteps=None, preallocated_resources=None) sdram_res = ConstantSDRAM(res_sdram) resources = ResourceContainer(sdram=sdram_res) chip_0 = machine.get_chip_at(0, 0) # verify core tracker is empty if (0, 0) in tracker._core_tracker: raise Exception("shouldnt exist") # verify sdram tracker if tracker._sdram_tracker[0, 0] != chip_sdram: raise Exception("incorrect sdram of {}".format( tracker._sdram_tracker[0, 0])) # allocate some res chip_x, chip_y, processor_id, ip_tags, reverse_ip_tags = \ tracker.allocate_resources(resources, [(0, 0)]) # verify chips used is updated cores = list(tracker._core_tracker[(0, 0)]) self.assertEqual(len(cores), chip_0.n_user_processors - 1) # verify sdram used is updated sdram = tracker._sdram_tracker[(0, 0)] self.assertEqual(sdram, chip_sdram-res_sdram) if (0, 0) not in tracker._chips_used: raise Exception("should exist") # deallocate res tracker.unallocate_resources( chip_x, chip_y, processor_id, resources, ip_tags, reverse_ip_tags) # verify chips used is updated if ((0, 0) in tracker._core_tracker and len(tracker._core_tracker[(0, 0)]) != chip_0.n_user_processors): raise Exception("shouldn't exist or should be right size") if (0, 0) in tracker._chips_used: raise Exception("shouldnt exist") # verify sdram tracker if tracker._sdram_tracker[0, 0] != chip_sdram: raise Exception("incorrect sdram of {}".format( tracker._sdram_tracker[0, 0]))
def test_1_chip_pre_allocated_too_much_sdram(self): machine = VirtualMachine(width=8, height=8) graph = ApplicationGraph("Test") partitioner = PartitionAndPlacePartitioner() eight_meg = 8 * 1024 * 1024 # add graph vertices which reside on 0,0 for _ in range(0, 13): graph.add_vertex( SimpleTestVertex(constraints=[ChipAndCoreConstraint(x=0, y=0)], n_atoms=1, fixed_sdram_value=eight_meg)) # add pre-allocated resources for cores on 0,0 twenty_meg = 20 * 1024 * 1024 core_pre = SpecificChipSDRAMResource(chip=machine.get_chip_at(0, 0), sdram_usage=twenty_meg) pre_allocated_res = PreAllocatedResourceContainer( specific_sdram_usage=[core_pre]) # run partitioner that should go boom try: partitioner(graph, machine, pre_allocated_res) raise Exception("should have blown up here") except PacmanPartitionException: pass except Exception: raise Exception("should have blown up here")
def test_1_chip_pre_allocated_same_core(self): machine = VirtualMachine(width=8, height=8) graph = ApplicationGraph("Test") partitioner = PartitionAndPlacePartitioner() # add graph vertices which reside on 0,0 for p in range(0, 13): graph.add_vertex( SimpleTestVertex( constraints=[ChipAndCoreConstraint(x=0, y=0, p=p)], n_atoms=1)) # add pre-allocated resources for cores on 0,0 core_pre = SpecificCoreResource(chip=machine.get_chip_at(0, 0), cores=[4]) pre_allocated_res = PreAllocatedResourceContainer( specific_core_resources=[core_pre]) # run partitioner that should go boom try: partitioner(graph, machine, pre_allocated_res) raise Exception("should have blown up here") except PacmanValueError: pass except Exception: raise Exception("should have blown up here")
def test_n_cores_available(self): machine = VirtualMachine( width=2, height=2, n_cpus_per_chip=18, with_monitors=True) chip = machine.get_chip_at(0, 0) preallocated_resources = PreAllocatedResourceContainer( specific_core_resources=[ SpecificCoreResource(chip=chip, cores=[1])], core_resources=[ CoreResource(chip=chip, n_cores=2)]) tracker = ResourceTracker( machine, plan_n_timesteps=None, preallocated_resources=preallocated_resources) # Should be 14 cores = 18 - 1 monitor - 1 specific core - 2 other cores self.assertEqual(tracker._n_cores_available(chip, (0, 0), None), 14) # Should be 0 since the core is already pre allocated self.assertEqual(tracker._n_cores_available(chip, (0, 0), 1), 0) # Should be 1 since the core is not pre allocated self.assertEqual(tracker._n_cores_available(chip, (0, 0), 2), 1) # Should be 0 since the core is monitor self.assertEqual(tracker._n_cores_available(chip, (0, 0), 0), 0) # Allocate a core tracker._allocate_core(chip, (0, 0), 2) # Should be 13 cores as one now allocated self.assertEqual(tracker._n_cores_available(chip, (0, 0), None), 13)
def test_1_chip_pre_allocated_too_much_sdram(self): machine = VirtualMachine(width=8, height=8) graph = ApplicationGraph("Test") partitioner = PartitionAndPlacePartitioner() eight_meg = 8 * 1024 * 1024 # add graph vertices which reside on 0,0 for _ in range(0, 13): graph.add_vertex(SimpleTestVertex( constraints=[ChipAndCoreConstraint(x=0, y=0)], n_atoms=1, fixed_sdram_value=eight_meg)) # add pre-allocated resources for cores on 0,0 twenty_meg = ConstantSDRAM(20 * 1024 * 1024) core_pre = SpecificChipSDRAMResource( chip=machine.get_chip_at(0, 0), sdram_usage=twenty_meg) pre_allocated_res = PreAllocatedResourceContainer( specific_sdram_usage=[core_pre]) # run partitioner that should go boom try: partitioner(graph, machine, plan_n_timesteps=None, preallocated_resources=pre_allocated_res) raise Exception("should have blown up here") except PacmanPartitionException: pass except Exception: exc_info = sys.exc_info() six.reraise(*exc_info)
def test_1_chip_pre_allocated_same_core(self): machine = VirtualMachine(width=8, height=8) graph = ApplicationGraph("Test") partitioner = PartitionAndPlacePartitioner() # add graph vertices which reside on 0,0 for p in range(0, 13): graph.add_vertex(SimpleTestVertex( constraints=[ChipAndCoreConstraint(x=0, y=0, p=p)], n_atoms=1)) # add pre-allocated resources for cores on 0,0 core_pre = SpecificCoreResource( chip=machine.get_chip_at(0, 0), cores=[4]) pre_allocated_res = PreAllocatedResourceContainer( specific_core_resources=[core_pre]) # run partitioner that should go boom try: partitioner(graph, machine, plan_n_timesteps=None, preallocated_resources=pre_allocated_res) raise Exception("should have blown up here") except PacmanValueError: pass except Exception: raise Exception("should have blown up here")
def test_ethernet_chips_exist(self): vm = VirtualMachine(width=48, height=24, with_wrap_arounds=True) for eth_chip in vm._ethernet_connected_chips: self.assertTrue(vm.get_chip_at(eth_chip.x, eth_chip.y), "Eth chip location x={}, y={} not in " "_configured_chips" .format(eth_chip.x, eth_chip.y))
def test_n_cores_available(self): machine = VirtualMachine(width=2, height=2, n_cpus_per_chip=18, with_monitors=True) chip = machine.get_chip_at(0, 0) preallocated_resources = PreAllocatedResourceContainer( specific_core_resources=[ SpecificCoreResource(chip=chip, cores=[1]) ], core_resources=[CoreResource(chip=chip, n_cores=2)]) tracker = ResourceTracker( machine, preallocated_resources=preallocated_resources) # Should be 14 cores = 18 - 1 monitor - 1 specific core - 2 other cores self.assertEqual(tracker._n_cores_available(chip, (0, 0), None), 14) # Should be 0 since the core is already pre allocated self.assertEqual(tracker._n_cores_available(chip, (0, 0), 1), 0) # Should be 1 since the core is not pre allocated self.assertEqual(tracker._n_cores_available(chip, (0, 0), 2), 1) # Should be 0 since the core is monitor self.assertEqual(tracker._n_cores_available(chip, (0, 0), 0), 0) # Allocate a core tracker._allocate_core(chip, (0, 0), 2) # Should be 13 cores as one now allocated self.assertEqual(tracker._n_cores_available(chip, (0, 0), None), 13)
def test_add__chip(self): vm = VirtualMachine(2, 2) _chip = self._create_chip(2, 2) vm.add_chip(_chip) self.assertEqual(vm.max_chip_x, 2) self.assertEqual(vm.max_chip_y, 2) self.assertEqual(5, vm.n_chips) self.assertTrue(vm.is_chip_at(2, 2)) _good = vm.get_chip_at(2, 2) self.assertEqual(_chip, _good) _bad = vm.get_chip_at(2, 1) self.assertIsNone(_bad) count = 0 for _chip in vm.chips: count += 1 self.assertTrue(5, count)
def test_deallocation_of_resources(self): machine = VirtualMachine(width=2, height=2, n_cpus_per_chip=18, with_monitors=True, sdram_per_chip=12346) tracker = ResourceTracker(machine, preallocated_resources=None) sdram_res = SDRAMResource(12345) resources = ResourceContainer(sdram=sdram_res) chip_0 = machine.get_chip_at(0, 0) # verify core tracker is empty if (0, 0) in tracker._core_tracker: raise Exception("shouldnt exist") # verify sdram tracker if tracker._sdram_tracker[0, 0] != -12346: raise Exception("incorrect sdram of {}".format( tracker._sdram_tracker[0, 0])) # allocate some res chip_x, chip_y, processor_id, ip_tags, reverse_ip_tags = \ tracker.allocate_resources(resources, [(0, 0)]) # verify chips used is updated cores = list(tracker._core_tracker[(0, 0)]) self.assertEqual(len(cores), chip_0.n_user_processors - 1) # verify sdram used is updated sdram = tracker._sdram_tracker[(0, 0)] self.assertEqual(sdram, -1) if (0, 0) not in tracker._chips_used: raise Exception("should exist") # deallocate res tracker.unallocate_resources(chip_x, chip_y, processor_id, resources, ip_tags, reverse_ip_tags) # verify chips used is updated if ((0, 0) in tracker._core_tracker and len( tracker._core_tracker[(0, 0)]) != chip_0.n_user_processors): raise Exception("shouldn't exist or should be right size") if (0, 0) in tracker._chips_used: raise Exception("shouldnt exist") # verify sdram tracker if tracker._sdram_tracker[0, 0] != -12346: raise Exception("incorrect sdram of {}".format( tracker._sdram_tracker[0, 0]))
def test_version_5_guess_12x12(self): vm = VirtualMachine(height=12, width=12, version=None, with_wrap_arounds=None) self.assertEqual(vm.max_chip_x, 11) self.assertEqual(vm.max_chip_y, 11) self.assertEqual(144, vm.n_chips) self.assertEqual(3, len(vm.ethernet_connected_chips)) count = sum(1 for _chip in vm.chips for _link in _chip.router.links) self.assertEqual(864, count) count = 0 for _chip in vm.get_chips_on_board(vm.get_chip_at(1, 1)): count += 1 self.assertEqual(48, count)
def test_too_many_ip_tags_for_1_board(self): n_extra_vertices = 3 machine = VirtualMachine(12, 12, with_wrap_arounds=True) eth_chips = machine.ethernet_connected_chips eth_chip = eth_chips[0] eth_chip_2 = machine.get_chip_at(eth_chip.x + 1, eth_chip.y + 1) eth_procs = [ proc.processor_id for proc in eth_chip.processors if not proc.is_monitor ] procs = [proc for proc in eth_chip_2.processors if not proc.is_monitor] eth2_procs = [proc.processor_id for proc in procs] proc = procs[-1] eth_vertices = [ SimpleMachineVertex(ResourceContainer( iptags=[IPtagResource("127.0.0.1", port=tag, strip_sdp=True)]), label="Ethernet Vertex {}".format(proc)) for tag in eth_chip.tag_ids ] eth2_vertices = [ SimpleMachineVertex(ResourceContainer(iptags=[ IPtagResource("127.0.0.1", port=10000 + tag, strip_sdp=True) ]), label="Ethernet 2 Vertex {}".format(proc)) for tag in range(n_extra_vertices) ] placements = Placements( Placement(vertex, eth_chip.x, eth_chip.y, proc) for proc, vertex in zip(eth_procs, eth_vertices)) placements.add_placements( Placement(vertex, eth_chip_2.x, eth_chip_2.y, proc) for proc, vertex in zip(eth2_procs, eth2_vertices)) allocator = BasicTagAllocator() _, _, tags = allocator(machine, placements) tags_by_board = defaultdict(set) for vertices in (eth_vertices, eth2_vertices): for vertex in vertices: iptags = tags.get_ip_tags_for_vertex(vertex) self.assertEqual(len(iptags), 1, "Incorrect number of tags assigned") placement = placements.get_placement_of_vertex(vertex) print(placement, "has tag", iptags[0]) self.assertFalse( iptags[0].tag in tags_by_board[iptags[0].board_address], "Tag used more than once") tags_by_board[iptags[0].board_address].add(iptags[0].tag) self.assertEqual(len(tags_by_board[eth_chip.ip_address]), len(eth_chip.tag_ids), "Wrong number of tags assigned to first Ethernet")
def test_too_many_ip_tags_for_1_board(self): n_extra_vertices = 3 machine = VirtualMachine(12, 12, with_wrap_arounds=True) eth_chips = machine.ethernet_connected_chips eth_chip = eth_chips[0] eth_chip_2 = machine.get_chip_at(eth_chip.x + 1, eth_chip.y + 1) eth_procs = [ proc.processor_id for proc in eth_chip.processors if not proc.is_monitor] procs = [proc for proc in eth_chip_2.processors if not proc.is_monitor] eth2_procs = [proc.processor_id for proc in procs] proc = procs[-1] eth_vertices = [ SimpleMachineVertex( ResourceContainer(iptags=[IPtagResource( "127.0.0.1", port=tag, strip_sdp=True)]), label="Ethernet Vertex {}".format(proc)) for tag in eth_chip.tag_ids] eth2_vertices = [ SimpleMachineVertex( ResourceContainer(iptags=[IPtagResource( "127.0.0.1", port=10000 + tag, strip_sdp=True)]), label="Ethernet 2 Vertex {}".format(proc)) for tag in range(n_extra_vertices)] placements = Placements( Placement(vertex, eth_chip.x, eth_chip.y, proc) for proc, vertex in zip(eth_procs, eth_vertices)) placements.add_placements( Placement(vertex, eth_chip_2.x, eth_chip_2.y, proc) for proc, vertex in zip(eth2_procs, eth2_vertices)) allocator = BasicTagAllocator() _, _, tags = allocator( machine, plan_n_timesteps=None, placements=placements) tags_by_board = defaultdict(set) for vertices in (eth_vertices, eth2_vertices): for vertex in vertices: iptags = tags.get_ip_tags_for_vertex(vertex) self.assertEqual( len(iptags), 1, "Incorrect number of tags assigned") placement = placements.get_placement_of_vertex(vertex) print(placement, "has tag", iptags[0]) self.assertFalse( iptags[0].tag in tags_by_board[iptags[0].board_address], "Tag used more than once") tags_by_board[iptags[0].board_address].add(iptags[0].tag) self.assertEqual( len(tags_by_board[eth_chip.ip_address]), len(eth_chip.tag_ids), "Wrong number of tags assigned to first Ethernet")
def test_exceptions(self): vm = VirtualMachine(version=5) chip22 = vm.get_chip_at(2, 2) router22 = chip22.router router22._clock_speed = router22._clock_speed - 10 router22._n_available_multicast_entries = \ router22._n_available_multicast_entries - 20 chip33 = vm.get_chip_at(3, 3) chip33._sdram = SDRAM(50000000) chip33._tag_ids = [2, 3] chip03 = vm.get_chip_at(0, 3) chip03._virtual = True jpath = mktemp("json") jpath = "temp.json" JsonMachine.to_json_path(vm, jpath) jm = JsonMachine(jpath) vstr = str(vm).replace("VirtualMachine", "Machine") jstr = str(jm).replace("JsonMachine", "Machine") self.assertEqual(vstr, jstr) for vchip, jchip in zip(vm, jm): print(vchip) print(jchip) self.assertEqual(str(vchip), str(jchip))
def test_version_2(self): vm = VirtualMachine(version=2, with_wrap_arounds=None) self.assertEqual(vm.max_chip_x, 1) self.assertEqual(vm.max_chip_y, 1) self.assertEqual(4, vm.n_chips) self.assertTrue(vm.is_chip_at(0, 0)) self.assertTrue(vm.is_chip_at(0, 1)) self.assertTrue(vm.is_chip_at(1, 0)) self.assertTrue(vm.is_chip_at(1, 1)) self.assertEqual(1, len(vm.ethernet_connected_chips)) self.assertTrue(vm.is_link_at(0, 0, 0)) self.assertTrue(vm.is_link_at(0, 0, 1)) self.assertTrue(vm.is_link_at(0, 0, 2)) self.assertFalse(vm.is_link_at(0, 0, 3)) self.assertFalse(vm.is_link_at(0, 0, 4)) self.assertTrue(vm.is_link_at(0, 0, 5)) self.assertTrue(vm.is_link_at(0, 1, 0)) self.assertTrue(vm.is_link_at(0, 1, 1)) self.assertTrue(vm.is_link_at(0, 1, 2)) self.assertFalse(vm.is_link_at(0, 1, 3)) self.assertFalse(vm.is_link_at(0, 1, 4)) self.assertTrue(vm.is_link_at(0, 1, 5)) self.assertFalse(vm.is_link_at(1, 0, 0)) self.assertFalse(vm.is_link_at(1, 0, 1)) self.assertTrue(vm.is_link_at(1, 0, 2)) self.assertTrue(vm.is_link_at(1, 0, 3)) self.assertTrue(vm.is_link_at(1, 0, 4)) self.assertTrue(vm.is_link_at(1, 0, 5)) self.assertFalse(vm.is_link_at(1, 1, 0)) self.assertFalse(vm.is_link_at(1, 1, 1)) self.assertTrue(vm.is_link_at(1, 1, 2)) self.assertTrue(vm.is_link_at(1, 1, 3)) self.assertTrue(vm.is_link_at(1, 1, 4)) self.assertTrue(vm.is_link_at(1, 1, 5)) count = 0 for _chip in vm.chips: for _link in _chip.router.links: count += 1 self.assertEqual(16, count) self.assertEqual(str(vm), "[VirtualMachine: max_x=1, max_y=1, n_chips=4]") self.assertEqual(vm.get_cores_and_link_count(), (72, 8)) count = 0 for _chip in vm.get_chips_on_board(vm.get_chip_at(1, 1)): count += 1 self.assertEqual(4, count)
def test_new_vm_with_monitor(self): n_cpus = 13 vm = VirtualMachine(2, 2, n_cpus_per_chip=n_cpus, with_monitors=True) self.assertEqual(vm.max_chip_x, 1) self.assertEqual(vm.max_chip_y, 1) self.assertEqual(n_cpus - 1, vm.maximum_user_cores_on_chip) _chip = vm.get_chip_at(1, 1) self.assertEqual(n_cpus, _chip.n_processors) monitors = 0 normal = 0 for core in _chip.processors: if core.is_monitor: monitors += 1 else: normal += 1 self.assertEqual(n_cpus - 1, normal) self.assertEqual(1, monitors)
def test_all_working( width, height, with_wrap_arounds, version, board_version, with_down_links, with_down_chips): router = FixedRouteRouter() joins, _ = router._get_joins_paths(board_version) temp_machine = VirtualMachine( width=width, height=height, with_wrap_arounds=with_wrap_arounds, version=version) 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, joins[1, 0])) down_links.add((ethernet_chip.x, ethernet_chip.y + 1, joins[0, 1])) 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) machine = VirtualMachine( width=width, height=height, with_wrap_arounds=with_wrap_arounds, version=version, down_links=down_links, down_chips=down_chips) ethernet_chips = machine.ethernet_connected_chips placements = Placements( Placement(DestinationVertex(), ethernet_chip.x, ethernet_chip.y, 1) for ethernet_chip in ethernet_chips) for ethernet_chip in ethernet_chips: uses_simple_routes = router._detect_failed_chips_on_board( machine, ethernet_chip, board_version) assert((with_down_chips or with_down_links) != uses_simple_routes) fixed_route_tables = router( machine, placements, board_version, DestinationVertex) for x, y in machine.chip_coordinates: assert (x, y) in fixed_route_tables chip = machine.get_chip_at(x, y) destinations = _get_destinations(machine, fixed_route_tables, x, y) assert len(destinations) == 1 assert ( (chip.nearest_ethernet_x, chip.nearest_ethernet_y, 1) in destinations)
def test_2_with_wrapparound(self): vm = VirtualMachine(height=2, width=2, with_wrap_arounds=True) self.assertEqual(vm.max_chip_x, 1) self.assertEqual(vm.max_chip_y, 1) self.assertEqual(4, vm.n_chips) self.assertEqual(1, len(vm.ethernet_connected_chips)) self.assertTrue(vm.is_link_at(0, 0, 5)) self.assertTrue(vm.is_link_at(0, 1, 2)) self.assertTrue(vm.is_link_at(0, 0, 4)) self.assertTrue(vm.is_link_at(0, 1, 3)) # Test that the chip south of 0, 0 is 0, 1 (with wrap around) chip = vm.get_chip_at(0, 0) link = chip.router.get_link(5) self.assertEqual(link.destination_x, 0) self.assertEqual(link.destination_y, 1) count = sum(1 for _chip in vm.chips for _link in _chip.router.links) self.assertEqual(24, count)
def test_added_pre_res(self): machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True) default_params = { 'use_prefix': False, 'key_prefix': None, 'prefix_type': None, 'message_type': EIEIOType.KEY_32_BIT, 'right_shift': 0, 'payload_as_time_stamps': True, 'use_payload_prefix': True, 'payload_prefix': None, 'payload_right_shift': 0, 'number_of_packets_sent_per_time_step': 0, 'hostname': None, 'port': None, 'strip_sdp': None, 'board_address': None, 'tag': None, 'label': "test" } # data stores needed by algorithm live_packet_gatherers = dict() extended = dict(default_params) extended.update({'partition_id': "EVENTS"}) default_params_holder = LivePacketGatherParameters(**extended) live_packet_gatherers[default_params_holder] = list() # create pre res sdram_requirements = { machine.get_chip_at(2, 2): 30000, machine.get_chip_at(7, 7): 50000 } core_requirements = {machine.get_chip_at(3, 3): 2} sdrams = list() cores = list() for chip in sdram_requirements: sdrams.append( SpecificChipSDRAMResource(chip, sdram_requirements[chip])) for chip in core_requirements: cores.append(CoreResource(chip, core_requirements[chip])) pre_pre_res = PreAllocatedResourceContainer( core_resources=cores, specific_sdram_usage=sdrams) # run pre allocator pre_alloc = PreAllocateResourcesForLivePacketGatherers() pre_res = pre_alloc( live_packet_gatherer_parameters=live_packet_gatherers, machine=machine, pre_allocated_resources=pre_pre_res) locs = list() locs.append((0, 0)) locs.append((4, 8)) locs.append((8, 4)) locs.append((2, 2)) locs.append((7, 7)) # verify sdram sdrams = pre_res.specific_sdram_usage for sdram in sdrams: locs.remove((sdram.chip.x, sdram.chip.y)) if sdram.sdram_usage != \ LivePacketGatherMachineVertex.get_sdram_usage(): self.assertIn(sdram.chip.x, (2, 7)) self.assertIn(sdram.chip.y, (2, 7)) self.assertEqual(sdram.chip.x, sdram.chip.y) if sdram.chip.x == 2 and sdram.chip.y == 2: self.assertEqual(sdram.sdram_usage, 30000) elif sdram.chip.x == 7 and sdram.chip.y == 7: self.assertEqual(sdram.sdram_usage, 50000) self.assertEqual(len(locs), 0) locs = list() locs.append((0, 0)) locs.append((4, 8)) locs.append((8, 4)) locs.append((3, 3)) # verify cores cores = pre_res.core_resources for core in cores: locs.remove((core.chip.x, core.chip.y)) if core.n_cores != 1: self.assertEqual(core.chip.x, 3) self.assertEqual(core.chip.y, 3) self.assertEqual(core.n_cores, 2) self.assertEqual(len(locs), 0) # verify specific cores self.assertEqual(len(pre_res.specific_core_resources), 0)