def test_one_lpg_params(self):
machine = virtual_machine(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.get_total_sdram(0),
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_one_lpg_params_and_3_specific(self):
machine = virtual_machine(width=12, height=12)
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,
'tag': None,
'label': "Test"
}
# data stores needed by algorithm
live_packet_gatherers = dict()
default_params_holder = LivePacketGatherParameters(**default_params)
live_packet_gatherers[default_params_holder] = list()
# and special LPG on Ethernet connected chips
for chip in machine.ethernet_connected_chips:
extended = dict(default_params)
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)
# verify sdram
locs = [(0, 0), (4, 8), (8, 4)]
sdrams = pre_res.specific_sdram_usage
for sdram in sdrams:
locs.remove((sdram.chip.x, sdram.chip.y))
self.assertEqual(
sdram.sdram_usage.get_total_sdram(0),
LivePacketGatherMachineVertex.get_sdram_usage() * 2)
self.assertEqual(len(locs), 0)
# verify cores
locs = {(0, 0): 0, (4, 8): 0, (8, 4): 0}
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 _add_mach_lpg_vertex(self, chip, params):
""" Adds a LPG vertex to a machine graph without an associated\
application graph.
:param ~.Chip chip:
:param LivePacketGatherParameters params:
:rtype: LivePacketGatherMachineVertex
"""
vtx = LivePacketGatherMachineVertex(
params, constraints=[ChipAndCoreConstraint(x=chip.x, y=chip.y)])
self._machine_graph.add_vertex(vtx)
return vtx
def __init__(self, label):
args = LivePacketGatherParameters(
port=globals.ack_port,
hostname=globals.host,
strip_sdp=True,
message_type=EIEIOType.KEY_PAYLOAD_32_BIT,
use_payload_prefix=False,
payload_as_time_stamps=False)
machine_vertex = LivePacketGatherMachineVertex(
args, label=label, constraints=[ChipAndCoreConstraint(x=0, y=0)])
super(Extractor, self).__init__(label, 1, [machine_vertex])
def __call__(self,
live_packet_gatherer_parameters,
machine,
pre_allocated_resources=None):
"""
:param live_packet_gatherer_parameters:
:type live_packet_gatherer_parameters:
dict(LivePacketGatherParameters,
list(tuple(~.AbstractVertex, list(str))))
:param ~.PreAllocatedResourceContainer pre_allocated_resources:
:param ~.Machine machine:
:rtype: ~.PreAllocatedResourceContainer
"""
progress = ProgressBar(len(machine.ethernet_connected_chips),
"Preallocating resources for Live Recording")
# store how much SDRAM the LPG uses per core
sdram_requirement = LPG.get_sdram_usage()
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
iptags = list()
for chip in progress.over(machine.ethernet_connected_chips):
self._add_chip_lpg_reqs(live_packet_gatherer_parameters, chip,
sdram_requirement, sdrams, cores, iptags)
# create preallocated resource container
lpg_prealloc_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams,
core_resources=cores,
specific_iptag_resources=iptags)
# add other preallocated resources
if pre_allocated_resources is not None:
lpg_prealloc_resource_container.extend(pre_allocated_resources)
# return preallocated resources
return lpg_prealloc_resource_container
def __call__(self,
live_packet_gatherer_parameters,
machine,
pre_allocated_resources=None):
"""
:param live_packet_gatherer_parameters:\
the LPG parameters requested by the script
:param previous_allocated_resources: other preallocated resources
:param machine: the SpiNNaker machine as discovered
:return: preallocated resources
"""
progress = ProgressBar(len(machine.ethernet_connected_chips),
"Preallocating resources for Live Recording")
# store how much SDRAM the LPG uses per core
lpg_sdram_requirement = LPGVertex.get_sdram_usage()
# for every Ethernet connected chip, get the resources needed by the
# live packet gatherers
sdrams = list()
cores = list()
iptags = list()
for chip in progress.over(machine.ethernet_connected_chips):
self._add_chip_lpg_reqs(live_packet_gatherer_parameters, chip,
lpg_sdram_requirement, sdrams, cores,
iptags)
# create pre allocated resource container
lpg_prealloc_resource_container = PreAllocatedResourceContainer(
specific_sdram_usage=sdrams,
core_resources=cores,
specific_iptag_resources=iptags)
# add other pre allocated resources
if pre_allocated_resources is not None:
lpg_prealloc_resource_container.extend(pre_allocated_resources)
# return pre allocated resources
return lpg_prealloc_resource_container
def test_added_pre_res(self):
machine = virtual_machine(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()
# 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, ConstantSDRAM(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.get_total_sdram(0) != \
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.get_total_sdram(0),
30000)
elif sdram.chip.x == 7 and sdram.chip.y == 7:
self.assertEqual(sdram.sdram_usage.get_total_sdram(0),
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_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_local_verts_when_multiple_lpgs_are_local(self):
machine = virtual_machine(width=12, height=12)
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,
'tag': None,
'label': "Test"}
# data stores needed by algorithm
live_packet_gatherers = dict()
default_params_holder = LivePacketGatherParameters(**default_params)
live_packet_gatherers[default_params_holder] = list()
live_packet_gatherers_to_vertex_mapping = defaultdict(dict)
placements = Placements()
# add LPG's (1 for each Ethernet connected chip)
specific_data_holders = dict()
index = 1
for chip in machine.ethernet_connected_chips:
extended = dict(default_params)
vertex = LivePacketGatherMachineVertex(
LivePacketGatherParameters(**extended), label='test')
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
# Add another on each chip separately
index += 1
extended = dict(default_params)
extended['board_address'] = chip.ip_address
default_params_holder2 = LivePacketGatherParameters(**extended)
extended = dict(default_params)
extended.update({'label': "test"})
vertex = LivePacketGatherMachineVertex(
LivePacketGatherParameters(**extended))
specific_data_holders[(chip.x, chip.y)] = default_params_holder2
placements.add_placement(Placement(
x=chip.x, y=chip.y, p=3, vertex=vertex))
graph.add_vertex(vertex)
live_packet_gatherers_to_vertex_mapping[
default_params_holder2][chip.x, chip.y] = vertex
live_packet_gatherers[default_params_holder2] = list()
# tracker of wirings
verts_expected = defaultdict(list)
positions = list()
positions.append([0, 0, 0, 0, 2, default_params_holder])
positions.append([4, 4, 0, 0, 2, default_params_holder])
positions.append(
[1, 1, 0, 0, 3, specific_data_holders[(0, 0)]])
positions.append(
[2, 2, 0, 0, 3, specific_data_holders[(0, 0)]])
positions.append([8, 4, 8, 4, 2, default_params_holder])
positions.append([11, 4, 8, 4, 2, default_params_holder])
positions.append([4, 11, 4, 8, 2, default_params_holder])
positions.append([4, 8, 4, 8, 2, default_params_holder])
positions.append([0, 11, 8, 4, 3, specific_data_holders[(8, 4)]])
positions.append([11, 11, 4, 8, 3, specific_data_holders[(4, 8)]])
positions.append([8, 8, 4, 8, 3, specific_data_holders[(4, 8)]])
positions.append([4, 0, 0, 0, 3, specific_data_holders[(0, 0)]])
positions.append([7, 7, 0, 0, 2, default_params_holder])
# add graph vertices which reside on areas of the machine to ensure
# spread over boards.
for x, y, eth_x, eth_y, eth_p, params in positions:
vertex = SimpleMachineVertex(resources=ResourceContainer())
graph.add_vertex(vertex)
live_packet_gatherers[params].append((vertex, ["EVENTS"]))
verts_expected[eth_x, eth_y, eth_p].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)
# verify edges are in the right place
for chip in machine.ethernet_connected_chips:
for params, p in zip(
(default_params_holder,
specific_data_holders[chip.x, chip.y]),
(2, 3)):
edges = graph.get_edges_ending_at_vertex(
live_packet_gatherers_to_vertex_mapping[
params][chip.x, chip.y])
for edge in edges:
self.assertIn(
edge.pre_vertex, verts_expected[chip.x, chip.y, p])
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)