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, 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 = 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_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_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_get_chips_on_boards(self):
vm = VirtualMachine(width=24, height=36, with_wrap_arounds=True)
# check each chip appears only once on the entire board
count00 = 0
count50 = 0
count04 = 0
count2436 = 0
for eth_chip in vm._ethernet_connected_chips:
list_of_chips = list(vm.get_chips_on_board(eth_chip))
self.assertEqual(len(list_of_chips), 48)
if (0, 0) in list_of_chips:
count00 += 1
if (5, 0) in list_of_chips:
count50 += 1
if (0, 4) in list_of_chips:
count04 += 1
if (24, 36) in list_of_chips:
count2436 += 1
# (0,0), (5,0), (0,4) are all on this virtual machine
self.assertEqual(count00, 1)
self.assertEqual(count50, 1)
self.assertEqual(count04, 1)
# (24,36) is not on this virtual machine
self.assertEqual(count2436, 0)
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 __call__(
self, width=None, height=None, virtual_has_wrap_arounds=None,
version=None, n_cpus_per_chip=Machine.MAX_CORES_PER_CHIP,
with_monitors=True, down_chips=None, down_cores=None,
down_links=None, max_sdram_size=None,
router_entries_per_chip=Router.ROUTER_DEFAULT_AVAILABLE_ENTRIES):
"""
:param width: The width of the machine in chips
:param height: The height of the machine in chips
:param virtual_has_wrap_arounds: \
True if the machine should be created with wrap_arounds
:param version: The version of board to create
:param n_cpus_per_chip: The number of cores to put on each chip
:param with_monitors: If true, CPU 0 will be marked as a monitor
:param down_chips: The set of chips that should be considered broken
:param down_cores: The set of cores that should be considered broken
:param down_links: The set of links that should be considered broken
:param max_sdram_size: The SDRAM that should be given to each chip
"""
# pylint: disable=too-many-arguments
machine = VirtualMachine(
width=width, height=height,
with_wrap_arounds=virtual_has_wrap_arounds,
version=version, n_cpus_per_chip=n_cpus_per_chip,
with_monitors=with_monitors, down_chips=down_chips,
down_cores=down_cores, down_links=down_links,
sdram_per_chip=max_sdram_size,
router_entries_per_chip=router_entries_per_chip)
# Work out and add the SpiNNaker links and FPGA links
machine.add_spinnaker_links(version)
machine.add_fpga_links(version)
return machine
def test_version_5(self):
vm = VirtualMachine(version=5)
self.assertEqual(vm.max_chip_x, 7)
self.assertEqual(vm.max_chip_y, 7)
self.assertEqual(48, vm.n_chips)
self.assertEqual(1, len(vm.ethernet_connected_chips))
self.assertTrue(vm.is_chip_at(4, 4))
self.assertFalse(vm.is_chip_at(0, 4))
count = sum(1 for _chip in vm.chips for _link in _chip.router.links)
self.assertEqual(240, 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_version_5_hole(self):
hole = [(3, 3)]
vm = VirtualMachine(version=5, down_chips=hole)
self.assertEqual(vm.max_chip_x, 7)
self.assertEqual(vm.max_chip_y, 7)
self.assertEqual(47, vm.n_chips)
self.assertEqual(1, len(vm.ethernet_connected_chips))
self.assertFalse(vm.is_link_at(3, 3, 2))
self.assertFalse(vm.is_link_at(3, 2, 2))
count = sum(1 for _chip in vm.chips for _link in _chip.router.links)
self.assertEqual(228, count)
def test_8_by_8(self):
vm = VirtualMachine(
width=8, height=8, version=None, with_wrap_arounds=False)
self.assertEqual(vm.max_chip_x, 7)
self.assertEqual(vm.max_chip_y, 7)
self.assertEqual(48, vm.n_chips)
self.assertEqual(1, len(vm.ethernet_connected_chips))
self.assertTrue(vm.is_chip_at(4, 4))
self.assertFalse(vm.is_chip_at(0, 4))
self.assertFalse((0, 4) in list(vm.chip_coordinates))
count = sum(1 for _chip in vm.chips for _link in _chip.router.links)
self.assertEqual(240, 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_2_no_wrapparound(self):
vm = VirtualMachine(height=2, width=2, with_wrap_arounds=False)
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.assertFalse(vm.is_link_at(0, 0, 5))
self.assertFalse(vm.is_link_at(0, 1, 2))
self.assertFalse(vm.is_link_at(0, 0, 4))
self.assertFalse(vm.is_link_at(0, 1, 3))
count = 0
for _chip in vm.chips:
for _link in _chip.router.links:
count += 1
self.assertEqual(10, count)
def test_ip_tags(self):
machine = VirtualMachine(12, 12, with_wrap_arounds=True)
eth_chips = machine.ethernet_connected_chips
vertices = [
SimpleMachineVertex(ResourceContainer(
iptags=[IPtagResource("127.0.0.1", port=None, strip_sdp=True)
]),
label="Vertex {}".format(i))
for i in range(len(eth_chips))
]
print("Created {} vertices".format(len(vertices)))
placements = Placements(
Placement(vertex, chip.x, chip.y, 1)
for vertex, chip in zip(vertices, eth_chips))
allocator = BasicTagAllocator()
_, _, tags = allocator(machine, placements)
for vertex, chip in zip(vertices, eth_chips):
iptags = tags.get_ip_tags_for_vertex(vertex)
self.assertEqual(len(iptags), 1,
"Incorrect number of tags assigned")
self.assertEqual(iptags[0].destination_x, chip.x,
"Destination of tag incorrect")
self.assertEqual(iptags[0].destination_y, chip.y,
"Destination of tag incorrect")
placement = placements.get_placement_of_vertex(vertex)
print(placement, "has tag", iptags[0])
def _do_test(self, placer):
machine = VirtualMachine(width=8, height=8)
graph = MachineGraph("Test")
vertices = [
SimpleMachineVertex(ResourceContainer(), label="v{}".format(i))
for i in range(100)
]
for vertex in vertices:
graph.add_vertex(vertex)
same_vertices = [
SimpleMachineVertex(ResourceContainer(), label="same{}".format(i))
for i in range(10)
]
random.seed(12345)
sdram_edges = list()
for vertex in same_vertices:
graph.add_vertex(vertex)
for i in range(0, random.randint(1, 5)):
sdram_edge = MachineEdge(
vertex, vertices[random.randint(0, 99)],
traffic_type=EdgeTrafficType.SDRAM)
sdram_edges.append(sdram_edge)
graph.add_edge(sdram_edge, "Test")
placements = placer(graph, machine)
for edge in sdram_edges:
pre_place = placements.get_placement_of_vertex(edge.pre_vertex)
post_place = placements.get_placement_of_vertex(edge.post_vertex)
self.assert_(pre_place.x == post_place.x)
self.assert_(pre_place.y == post_place.y)
def test_one_lpg_params(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
}
# 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()
# run pre allocator
pre_alloc = PreAllocateResourcesForLivePacketGatherers()
pre_res = pre_alloc(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine)
locs = list()
locs.append((0, 0))
locs.append((4, 8))
locs.append((8, 4))
# verify sdram
sdrams = pre_res.specific_sdram_usage
for sdram in sdrams:
locs.remove((sdram.chip.x, sdram.chip.y))
self.assertEqual(sdram.sdram_usage,
LivePacketGatherMachineVertex.get_sdram_usage())
self.assertEqual(len(locs), 0)
locs = list()
locs.append((0, 0))
locs.append((4, 8))
locs.append((8, 4))
# verify cores
cores = pre_res.core_resources
for core in cores:
locs.remove((core.chip.x, core.chip.y))
self.assertEqual(core.n_cores, 1)
self.assertEqual(len(locs), 0)
# verify specific cores
self.assertEqual(len(pre_res.specific_core_resources), 0)
def test_fail(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
live_packet_gatherers = dict()
pre_alloc = PreAllocateResourcesForLivePacketGatherers()
self.assertRaises(
Exception,
pre_alloc(live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine))
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_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_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_that_6_lpgs_are_generated_2_on_each_eth_chip(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
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()
# and special LPG on Ethernet connected chips
index = 1
chip_special = dict()
for chip in machine.ethernet_connected_chips:
extended['label'] = "test{}".format(index)
extended['board_address'] = chip.ip_address
default_params_holder2 = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder2] = list()
chip_special[(chip.x, chip.y)] = default_params_holder2
# run edge inserter that should go boom
edge_inserter = InsertLivePacketGatherersToGraphs()
lpg_verts_mapping = edge_inserter(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine,
machine_graph=graph,
application_graph=None,
graph_mapper=None)
self.assertEqual(len(lpg_verts_mapping[default_params_holder]), 3)
for eth_chip in chip_special:
params = chip_special[eth_chip]
self.assertEqual(len(lpg_verts_mapping[params]), 1)
vertex = lpg_verts_mapping[params][eth_chip]
self.assertEqual(eth_chip[0], list(vertex.constraints)[0].x)
self.assertEqual(eth_chip[1], list(vertex.constraints)[0].y)
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_that_3_lpgs_are_generated_on_3_board(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
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()
# run edge inserter that should go boom
edge_inserter = InsertLivePacketGatherersToGraphs()
lpg_verts_mapping = edge_inserter(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine,
machine_graph=graph,
application_graph=None,
graph_mapper=None)
self.assertEqual(len(lpg_verts_mapping[default_params_holder]), 3)
locs = list()
locs.append((0, 0))
locs.append((4, 8))
locs.append((8, 4))
for vertex in lpg_verts_mapping[default_params_holder].itervalues():
x = list(vertex.constraints)[0].x
y = list(vertex.constraints)[0].y
key = (x, y)
locs.remove(key)
self.assertEqual(len(locs), 0)
verts = lpg_verts_mapping[default_params_holder].values()
for vertex in graph.vertices:
self.assertIn(vertex, verts)
def test_none(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
live_packet_gatherers = dict()
# run pre allocator
pre_alloc = PreAllocateResourcesForLivePacketGatherers()
pre_res = pre_alloc(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine)
self.assertEqual(len(pre_res.specific_core_resources), 0)
self.assertEqual(len(pre_res.core_resources), 0)
self.assertEqual(len(pre_res.specific_sdram_usage), 0)
def __call__(
self, width=None, height=None, virtual_has_wrap_arounds=None,
version=None, n_cpus_per_chip=18, with_monitors=True,
down_chips=None, down_cores=None, down_links=None):
"""
:param width: The width of the machine in chips
:param height: The height of the machine in chips
:param virtual_has_wrap_arounds: True if the machine\
should be created with wrap_arounds
:param version: The version of board to create
:param n_cpus_per_chip: The number of cores to put on each chip
:param with_monitors: If true, CPU 0 will be marked as a monitor
"""
machine = VirtualMachine(
width=width, height=height,
with_wrap_arounds=virtual_has_wrap_arounds,
version=version, n_cpus_per_chip=n_cpus_per_chip,
with_monitors=with_monitors, down_chips=down_chips,
down_cores=down_cores, down_links=down_links)
# Work out and add the spinnaker links and FPGA links
machine.add_spinnaker_links(version)
machine.add_fpga_links(version)
return machine
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_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
def _do_test(self, placer):
machine = VirtualMachine(width=8, height=8)
graph = MachineGraph("Test")
vertices = [
SimpleMachineVertex(ResourceContainer(), label="v{}".format(i))
for i in range(100)
]
for vertex in vertices:
graph.add_vertex(vertex)
same_vertices = [
SimpleMachineVertex(ResourceContainer(), label="same{}".format(i))
for i in range(10)
]
random.seed(12345)
for vertex in same_vertices:
graph.add_vertex(vertex)
for i in range(0, random.randint(1, 5)):
vertex.add_constraint(
SameChipAsConstraint(vertices[random.randint(0, 99)]))
placements = placer(graph, machine)
for same in same_vertices:
print("{0.vertex.label}, {0.x}, {0.y}, {0.p}: {1}".format(
placements.get_placement_of_vertex(same), [
"{0.vertex.label}, {0.x}, {0.y}, {0.p}".format(
placements.get_placement_of_vertex(constraint.vertex))
for constraint in same.constraints
]))
placement = placements.get_placement_of_vertex(same)
for constraint in same.constraints:
if isinstance(constraint, SameChipAsConstraint):
other_placement = placements.get_placement_of_vertex(
constraint.vertex)
self.assert_(
other_placement.x == placement.x
and other_placement.y == placement.y,
"Vertex was not placed on the same chip as requested")
def test_1_chip_no_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
pre_allocated_res = PreAllocatedResourceContainer()
# run partitioner that should go boom
try:
partitioner(graph, machine, pre_allocated_res)
except Exception:
raise Exception("should have blown up here")
def __call__(
self,
width=None,
height=None,
virtual_has_wrap_arounds=None,
version=None,
n_cpus_per_chip=Machine.MAX_CORES_PER_CHIP,
with_monitors=True,
down_chips=None,
down_cores=None,
down_links=None,
max_sdram_size=None,
router_entries_per_chip=Router.ROUTER_DEFAULT_AVAILABLE_ENTRIES):
"""
:param width: The width of the machine in chips
:param height: The height of the machine in chips
:param virtual_has_wrap_arounds: \
True if the machine should be created with wrap_arounds
:param version: The version of board to create
:param n_cpus_per_chip: The number of cores to put on each chip
:param with_monitors: If true, CPU 0 will be marked as a monitor
:param down_chips: The set of chips that should be considered broken
:param down_cores: The set of cores that should be considered broken
:param down_links: The set of links that should be considered broken
:param max_sdram_size: The SDRAM that should be given to each chip
"""
# pylint: disable=too-many-arguments
machine = VirtualMachine(
width=width,
height=height,
with_wrap_arounds=virtual_has_wrap_arounds,
version=version,
n_cpus_per_chip=n_cpus_per_chip,
with_monitors=with_monitors,
down_chips=down_chips,
down_cores=down_cores,
down_links=down_links,
sdram_per_chip=max_sdram_size,
router_entries_per_chip=router_entries_per_chip)
# Work out and add the SpiNNaker links and FPGA links
machine.add_spinnaker_links(version)
machine.add_fpga_links(version)
return machine
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_local_verts_go_to_local_lpgs(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
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()
live_packet_gatherers_to_vertex_mapping = dict()
live_packet_gatherers_to_vertex_mapping[default_params_holder] = dict()
placements = Placements()
# add LPG's (1 for each Ethernet connected chip)
for chip in machine.ethernet_connected_chips:
vertex = LivePacketGatherMachineVertex(**default_params)
graph.add_vertex(vertex)
placements.add_placement(
Placement(x=chip.x, y=chip.y, p=2, vertex=vertex))
live_packet_gatherers_to_vertex_mapping[default_params_holder][
chip.x, chip.y] = vertex
# tracker of wirings
verts_expected = defaultdict(list)
positions = list()
positions.append([0, 0, 0, 0])
positions.append([4, 4, 0, 0])
positions.append([1, 1, 0, 0])
positions.append([2, 2, 0, 0])
positions.append([8, 4, 8, 4])
positions.append([11, 4, 8, 4])
positions.append([4, 11, 4, 8])
positions.append([4, 8, 4, 8])
positions.append([0, 11, 8, 4])
positions.append([11, 11, 4, 8])
positions.append([8, 8, 4, 8])
positions.append([4, 0, 0, 0])
positions.append([7, 7, 0, 0])
# add graph vertices which reside on areas of the machine to ensure
# spread over boards.
for x, y, eth_x, eth_y in positions:
vertex = SimpleMachineVertex(resources=ResourceContainer())
graph.add_vertex(vertex)
live_packet_gatherers[default_params_holder].append(vertex)
verts_expected[eth_x, eth_y].append(vertex)
placements.add_placement(Placement(x=x, y=y, p=5, vertex=vertex))
# run edge inserter that should go boom
edge_inserter = InsertEdgesToLivePacketGatherers()
edge_inserter(live_packet_gatherer_parameters=live_packet_gatherers,
placements=placements,
live_packet_gatherers_to_vertex_mapping=(
live_packet_gatherers_to_vertex_mapping),
machine=machine,
machine_graph=graph,
application_graph=None,
graph_mapper=None)
# verify edges are in the right place
for chip in machine.ethernet_connected_chips:
edges = graph.get_edges_ending_at_vertex(
live_packet_gatherers_to_vertex_mapping[default_params_holder][
chip.x, chip.y])
for edge in edges:
self.assertIn(edge.pre_vertex, verts_expected[chip.x, chip.y])
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)
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_one_lpg_params_and_3_specific(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()
# and special LPG on Ethernet connected chips
index = 1
for chip in machine.ethernet_connected_chips:
extended['label'] = "test{}".format(index)
extended['board_address'] = chip.ip_address
default_params_holder2 = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder2] = list()
pre_alloc = PreAllocateResourcesForLivePacketGatherers()
pre_res = pre_alloc(
live_packet_gatherer_parameters=live_packet_gatherers,
machine=machine)
locs = list()
locs.append((0, 0))
locs.append((4, 8))
locs.append((8, 4))
# verify sdram
sdrams = pre_res.specific_sdram_usage
for sdram in sdrams:
locs.remove((sdram.chip.x, sdram.chip.y))
self.assertEqual(
sdram.sdram_usage,
LivePacketGatherMachineVertex.get_sdram_usage() * 2)
self.assertEqual(len(locs), 0)
locs = dict()
locs[(0, 0)] = 0
locs[(4, 8)] = 0
locs[(8, 4)] = 0
# verify cores
cores = pre_res.core_resources
for core in cores:
locs[(core.chip.x, core.chip.y)] += core.n_cores
for (x, y) in [(0, 0), (4, 8), (8, 4)]:
self.assertEqual(locs[x, y], 2)
# verify specific cores
self.assertEqual(len(pre_res.specific_core_resources), 0)
def test_add_existing_chip(self):
vm = VirtualMachine(2, 2)
_chip = self._create_chip(1, 1)
with self.assertRaises(SpinnMachineAlreadyExistsException):
vm.add_chip(_chip)