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 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_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 update_live_packet_gather_tracker( vertex_to_record_from, lpg_label, port=None, hostname=None, board_address=None, tag=None, strip_sdp=True, 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, partition_ids=None): """ Add an edge from a vertex to the live packet gatherer, builds as\ needed and has all the parameters for the creation of the live\ packet gatherer if needed. """ # pylint: disable=too-many-arguments, too-many-locals params = LivePacketGatherParameters( port=port, hostname=hostname, tag=tag, board_address=board_address, strip_sdp=strip_sdp, use_prefix=use_prefix, key_prefix=key_prefix, prefix_type=prefix_type, message_type=message_type, right_shift=right_shift, payload_prefix=payload_prefix, payload_as_time_stamps=payload_as_time_stamps, use_payload_prefix=use_payload_prefix, payload_right_shift=payload_right_shift, number_of_packets_sent_per_time_step=( number_of_packets_sent_per_time_step), label=lpg_label) # add to the tracker get_simulator().add_live_packet_gatherer_parameters( params, vertex_to_record_from, partition_ids)
def test_that_3_lpgs_are_generated_on_3_board_app_graph(self): machine = virtual_machine(width=12, height=12) app_graph = ApplicationGraph("Test") graph = MachineGraph("Test", app_graph) 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() # 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=app_graph) 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 itervalues(lpg_verts_mapping[default_params_holder]): 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) app_verts = set() for vertex in itervalues(lpg_verts_mapping[default_params_holder]): app_vertex = vertex.app_vertex self.assertNotEqual(app_vertex, None) self.assertIsInstance(app_vertex, ApplicationVertex) app_verts.add(app_vertex) self.assertEqual(len(app_verts), 3)
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 __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 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 update_live_packet_gather_tracker( vertex_to_record_from, lpg_label, port=None, hostname=None, tag=None, strip_sdp=True, 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, partition_ids=None): """ Add an edge from a vertex to the live packet gatherer, builds as\ needed and has all the parameters for the creation of the live\ packet gatherer if needed. :param vertex_to_record_from: :type vertex_to_record_from: ~pacman.model.graphs.application.ApplicationVertex or ~pacman.model.graphs.machine.MachineVertex :param str lpg_label: :param int port: :param str hostname: :param int tag: :param bool strip_sdp: :param bool use_prefix: :param int key_prefix: :param ~spinnman.messages.eieio.EIEIOPrefix prefix_type: :param ~spinnman.messages.eieio.EIEIOType message_type: :param int right_shift: :param bool payload_as_time_stamps: :param bool use_payload_prefix: :param int payload_prefix: :param int payload_right_shift: :param int number_of_packets_sent_per_time_step: :param list(str) partition_ids: """ # pylint: disable=too-many-arguments, too-many-locals params = LivePacketGatherParameters( port=port, hostname=hostname, tag=tag, strip_sdp=strip_sdp, use_prefix=use_prefix, key_prefix=key_prefix, prefix_type=prefix_type, message_type=message_type, right_shift=right_shift, payload_prefix=payload_prefix, payload_as_time_stamps=payload_as_time_stamps, use_payload_prefix=use_payload_prefix, payload_right_shift=payload_right_shift, number_of_packets_sent_per_time_step=( number_of_packets_sent_per_time_step), label=lpg_label) # add to the tracker get_simulator().add_live_packet_gatherer_parameters( params, vertex_to_record_from, partition_ids)
def test_local_verts_go_to_local_lpgs_app_graph(self): machine = virtual_machine(width=12, height=12) app_graph = ApplicationGraph("Test") graph = MachineGraph("Test", app_graph) 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 for chip in machine.ethernet_connected_chips: new_params = dict(default_params) vertex = LivePacketGather( LivePacketGatherParameters(**new_params)) app_graph.add_vertex(vertex) vertex_slice = None resources_required = vertex.get_resources_used_by_atoms( vertex_slice) mac_vertex = vertex.create_machine_vertex( vertex_slice, resources_required) graph.add_vertex(mac_vertex) placements.add_placement( Placement(x=chip.x, y=chip.y, p=2, vertex=mac_vertex)) live_packet_gatherers_to_vertex_mapping[ default_params_holder][chip.x, chip.y] = mac_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 = SimpleTestVertex(1) app_graph.add_vertex(vertex) vertex_slice = Slice(0, 0) resources_required = vertex.get_resources_used_by_atoms( vertex_slice) mac_vertex = vertex.create_machine_vertex( vertex_slice, resources_required) graph.add_vertex(mac_vertex) partition_ids = ["EVENTS"] live_packet_gatherers[default_params_holder].append( (vertex, partition_ids)) verts_expected[eth_x, eth_y].append(mac_vertex) placements.add_placement( Placement(x=x, y=y, p=5, vertex=mac_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=app_graph) # 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]) # check app graph for chip in machine.ethernet_connected_chips: app_verts_expected = [ vert.app_vertex for vert in verts_expected[chip.x, chip.y]] lpg_machine = live_packet_gatherers_to_vertex_mapping[ default_params_holder][chip.x, chip.y] for edge in app_graph.get_edges_ending_at_vertex( lpg_machine.app_vertex): self.assertIn(edge.pre_vertex, app_verts_expected)
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_that_6_lpgs_are_generated_2_on_each_eth_chip_app_graph(self): machine = virtual_machine(width=12, height=12) app_graph = ApplicationGraph("Test") graph = MachineGraph("Test", app_graph) 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 chip_special = dict() 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() 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=app_graph) 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) verts = list(lpg_verts_mapping[default_params_holder].values()) for params in chip_special.values(): verts.extend(lpg_verts_mapping[params].values()) for vertex in graph.vertices: self.assertIn(vertex, verts) app_verts = set() for vertex in verts: app_vertex = vertex.app_vertex self.assertIsInstance(app_vertex, ApplicationVertex) app_verts.add(app_vertex) self.assertEqual(len(app_verts), 6)
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)