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)