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)