def _integration_setup(self): machine_graph = MachineGraph(label="test me you git") n_keys_map = DictBasedMachinePartitionNKeysMap() v1 = SimpleMachineVertex(ResourceContainer()) v2 = SimpleMachineVertex(ResourceContainer()) v3 = SimpleMachineVertex(ResourceContainer()) v4 = SimpleMachineVertex(ResourceContainer()) machine_graph.add_vertex(v1) machine_graph.add_vertex(v2) machine_graph.add_vertex(v3) machine_graph.add_vertex(v4) e1 = MachineEdge(v1, v2, label="e1") e2 = MachineEdge(v1, v3, label="e2") e3 = MachineEdge(v2, v3, label="e3") e4 = MachineEdge(v1, v4, label="e4") machine_graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="part1", pre_vertex=v1)) machine_graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="part2", pre_vertex=v2)) machine_graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="part2", pre_vertex=v1)) machine_graph.add_edge(e1, "part1") machine_graph.add_edge(e2, "part1") machine_graph.add_edge(e3, "part2") machine_graph.add_edge(e4, "part2") for partition in machine_graph.outgoing_edge_partitions: n_keys_map.set_n_keys_for_partition(partition, 24) return machine_graph, n_keys_map, v1, v2, v3, v4, e1, e2, e3, e4
def setUp(self): unittest_setup() self.machine = virtual_machine(8, 8) self.mach_graph = MachineGraph("machine") self.vertices = list() self.vertex1 = get_resourced_machine_vertex(0, 1, "First vertex") self.vertex2 = get_resourced_machine_vertex(1, 5, "Second vertex") self.vertex3 = get_resourced_machine_vertex(5, 10, "Third vertex") self.vertex4 = get_resourced_machine_vertex(10, 100, "Fourth vertex") self.vertices.append(self.vertex1) self.mach_graph.add_vertex(self.vertex1) self.vertices.append(self.vertex2) self.mach_graph.add_vertex(self.vertex2) self.vertices.append(self.vertex3) self.mach_graph.add_vertex(self.vertex3) self.vertices.append(self.vertex4) self.mach_graph.add_vertex(self.vertex4) self.edges = list() edge1 = MachineEdge(self.vertex2, self.vertex3) self.edges.append(edge1) self.mach_graph.add_edge(edge1, "packet") edge2 = MachineEdge(self.vertex2, self.vertex4) self.edges.append(edge2) self.mach_graph.add_edge(edge2, "packet") edge3 = MachineEdge(self.vertex3, self.vertex4) self.edges.append(edge3) self.mach_graph.add_edge(edge3, "packet") edge4 = MachineEdge(self.vertex3, self.vertex1) self.edges.append(edge4) self.plan_n_timesteps = 100
def test_get_edge_from_machine_edge(self): """ test that tests getting a edge from a graph mapper """ vertices = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) edges = list() edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(vertices[1], vertices[1])) sube = MachineEdge(vertices[1], vertices[0]) edges.append(sube) # Create the graph mapper graph = GraphMapper() edge = SimpleTestEdge(SimpleTestVertex(10, "pre"), SimpleTestVertex(5, "post")) graph.add_edge_mapping(sube, edge) graph.add_edge_mapping(edges[0], edge) edge_from_machine_edge = graph.get_application_edge(sube) self.assertEqual(edge_from_machine_edge, edge) self.assertEqual( graph.get_application_edge(edges[0]), edge) self.assertIsNone(graph.get_application_edge(edges[1]))
def test_get_vertices_from_vertex(self): """ test getting the vertex from a graph mapper via the vertex """ vertices = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) vertex1 = SimpleMachineVertex(None, "") vertex2 = SimpleMachineVertex(None, "") edges = list() edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(vertices[1], vertices[1])) graph_mapper = GraphMapper() vert = SimpleTestVertex(4, "Some testing vertex") vertex_slice = Slice(0, 1) graph_mapper.add_vertex_mapping(vertex1, vertex_slice, vert) vertex_slice = Slice(2, 3) graph_mapper.add_vertex_mapping(vertex2, vertex_slice, vert) returned_vertices = graph_mapper.get_machine_vertices(vert) self.assertIn(vertex1, returned_vertices) self.assertIn(vertex2, returned_vertices) for v in vertices: self.assertNotIn(v, returned_vertices)
def test_new_graph(self): """ tests that after building a machine graph, all partitined vertices and partitioned edges are in existence """ vertices = list() edges = list() for i in range(10): vertices.append( SimpleMachineVertex(ResourceContainer(), "V{}".format(i))) with self.assertRaises(NotImplementedError): vertices[1].add_constraint(SameAtomsAsVertexConstraint( vertices[4])) vertices[4].add_constraint(SameAtomsAsVertexConstraint( vertices[1])) for i in range(5): edges.append(MachineEdge(vertices[0], vertices[(i + 1)])) for i in range(5, 10): edges.append(MachineEdge(vertices[5], vertices[(i + 1) % 10])) graph = MachineGraph("foo") graph.add_vertices(vertices) graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="bar", pre_vertex=vertices[0])) graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="bar", pre_vertex=vertices[5])) graph.add_edges(edges, "bar") self.graph_there_and_back(graph)
def __init__(self, pre_vertex, post_vertex, direction, n_keys=1, label=None): MachineEdge.__init__(self, pre_vertex, post_vertex, label=label) self._direction = direction
def __init__(self, pre_vertex, post_vertex, label, weight=1): MachineEdge.__init__(self, pre_vertex, post_vertex, label=label, traffic_weight=weight) AbstractFilterableEdge.__init__(self) AbstractWeightUpdatable.__init__(self)
def __init__(self, pre_vertex, post_vertex, sdram_size, label): MachineEdge.__init__(self, pre_vertex, post_vertex, traffic_type=EdgeTrafficType.SDRAM, label=label, traffic_weight=1) self._sdram_size = sdram_size self._sdram_base_address = None
def test_one_to_one(): """ Test normal 1-1 placement """ # Create a graph machine_graph = MachineGraph("Test") # Connect a set of vertices in a chain of length 3 one_to_one_chains = list() for i in range(10): last_vertex = None chain = list() for j in range(3): vertex = SimpleMachineVertex(resources=ResourceContainer(), label="Vertex_{}_{}".format(i, j)) machine_graph.add_vertex(vertex) if last_vertex is not None: edge = MachineEdge(last_vertex, vertex) machine_graph.add_edge(edge, "SPIKES") last_vertex = vertex chain.append(vertex) one_to_one_chains.append(chain) # Connect a set of 20 vertices in a chain too_many_vertices = list() last_vertex = None for i in range(20): vertex = SimpleMachineVertex(resources=ResourceContainer(), label="Vertex_{}".format(i)) machine_graph.add_vertex(vertex) if last_vertex is not None: edge = MachineEdge(last_vertex, vertex) machine_graph.add_edge(edge, "SPIKES") too_many_vertices.append(vertex) last_vertex = vertex # Do placements machine = virtual_machine(width=8, height=8) placements = OneToOnePlacer()(machine_graph, machine, plan_n_timesteps=1000) # The 1-1 connected vertices should be on the same chip for chain in one_to_one_chains: first_placement = placements.get_placement_of_vertex(chain[0]) for i in range(1, 3): placement = placements.get_placement_of_vertex(chain[i]) assert placement.x == first_placement.x assert placement.y == first_placement.y # The other vertices should be on more than one chip too_many_chips = set() for vertex in too_many_vertices: placement = placements.get_placement_of_vertex(vertex) too_many_chips.add((placement.x, placement.y)) assert len(too_many_chips) > 1
def __init__(self, pre_vertex, post_vertex, label, app_edge=None): MachineEdge.__init__(self, pre_vertex, post_vertex, traffic_type=EdgeTrafficType.SDRAM, label=label, traffic_weight=1, app_edge=app_edge) (pre_vertex_sdram, post_vertex_sdram) = self.__get_vertex_sdrams() self._sdram_size = self.__check_vertex_sdram_sizes( pre_vertex_sdram, post_vertex_sdram) self._sdram_base_address = None
def __init__(self, synapse_information, pre_vertex, post_vertex, label=None, weight=1): MachineEdge.__init__(self, pre_vertex, post_vertex, label=label, traffic_weight=weight) AbstractFilterableEdge.__init__(self) self._synapse_information = synapse_information
def test_add_edge_with_no_existing_pre_vertex_in_graph(self): """ test that adding a edge where the pre vertex has not been added to the machine graph causes an error """ vertices = list() edges = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(SimpleMachineVertex(None, ""), vertices[0])) with self.assertRaises(PacmanInvalidParameterException): graph = MachineGraph("foo") graph.add_vertices(vertices) graph.add_edges(edges, "bar")
def __init__(self, pre_vertex, post_vertex, input_port, reception_parameters, traffic_weight, label=None): MachineEdge.__init__(self, pre_vertex, post_vertex, traffic_type=EdgeTrafficType.MULTICAST, label=label, traffic_weight=traffic_weight) self._input_port = input_port self._reception_parameters = reception_parameters
def test_ner_route_default(): unittest_setup() graph = MachineGraph("Test") machine = virtual_machine(8, 8) placements = Placements() source_vertex = SimpleMachineVertex(None) graph.add_vertex(source_vertex) placements.add_placement(Placement(source_vertex, 0, 0, 1)) target_vertex = SimpleMachineVertex(None) graph.add_vertex(target_vertex) placements.add_placement(Placement(target_vertex, 0, 2, 1)) edge = MachineEdge(source_vertex, target_vertex) graph.add_edge(edge, "Test") partition = graph.get_outgoing_partition_for_edge(edge) routes = ner_route(graph, machine, placements) source_route = routes.get_entries_for_router(0, 0)[partition] assert (not source_route.defaultable) mid_route = routes.get_entries_for_router(0, 1)[partition] print(mid_route.incoming_link, mid_route.link_ids) assert (mid_route.defaultable) end_route = routes.get_entries_for_router(0, 2)[partition] assert (not end_route.defaultable)
def test_add_duplicate_vertex(self): """ testing that adding the same machine vertex twice will cause an error """ vertices = list() edges = list() subv = SimpleMachineVertex(None, "") vertices.append(subv) vertices.append(SimpleMachineVertex(None, "")) vertices.append(subv) edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(vertices[1], vertices[0])) graph = MachineGraph("foo") graph.add_vertices(vertices) graph.add_edges(edges, "bar")
def run(self, mbs, x, y): # setup system sim.setup(model_binary_module=( speed_tracker_with_protocol_search_c_code_version)) # build verts reader = SDRAMReaderAndTransmitterWithProtocol(mbs) reader.add_constraint(ChipAndCoreConstraint(x=x, y=y)) receiver = PacketGathererWithProtocol() # add verts to graph sim.add_machine_vertex_instance(reader) sim.add_machine_vertex_instance(receiver) # build and add edge to graph sim.add_machine_edge_instance(MachineEdge(reader, receiver), "TRANSMIT") machine = sim.machine() if machine.is_chip_at(x, y): return self._do_run(reader, receiver, mbs) else: sim.stop() return None, False, False, "", 0
def test_routing(self): graph = MachineGraph("Test") machine = VirtualMachine(2, 2) placements = Placements() vertices = list() for x in range(machine.max_chip_x + 1): for y in range(machine.max_chip_y + 1): chip = machine.get_chip_at(x, y) if chip is not None: for processor in chip.processors: if not processor.is_monitor: vertex = SimpleMachineVertex( resources=ResourceContainer()) graph.add_vertex(vertex) placements.add_placement( Placement(vertex, x, y, processor.processor_id)) vertices.append(vertex) for vertex in vertices: for vertex_to in vertices: if vertex != vertex_to: graph.add_edge(MachineEdge(vertex, vertex_to), "Test") router = BasicDijkstraRouting() routing_paths = router.__call__(placements, machine, graph) for vertex in vertices: vertices_reached = set() queue = deque() seen_entries = set() placement = placements.get_placement_of_vertex(vertex) partition = graph.get_outgoing_edge_partition_starting_at_vertex( vertex, "Test") entry = routing_paths.get_entry_on_coords_for_edge( partition, placement.x, placement.y) self.assertEqual(entry.incoming_processor, placement.p) queue.append((placement.x, placement.y)) while len(queue) > 0: x, y = queue.pop() entry = routing_paths.get_entry_on_coords_for_edge( partition, x, y) self.assertIsNotNone(entry) chip = machine.get_chip_at(x, y) for p in entry.out_going_processors: self.assertIsNotNone(chip.get_processor_with_id(p)) vertex_found = placements.get_vertex_on_processor(x, y, p) vertices_reached.add(vertex_found) seen_entries.add((x, y)) for link_id in entry.out_going_links: link = chip.router.get_link(link_id) self.assertIsNotNone(link) dest_x, dest_y = link.destination_x, link.destination_y if (dest_x, dest_y) not in seen_entries: queue.append((dest_x, dest_y)) for vertex_to in vertices: if vertex != vertex_to: self.assertIn(vertex_to, vertices_reached)
def _process_m_vertex(self, machine_vertex, m_lpgs, machine, placements, machine_graph, partition_id): """ Locates and places an edge for a machine vertex. :param machine_vertex: the machine vertex that needs an edge to a LPG :param m_lpgs:\ dict of chip placed on to gatherers that are associated with the\ parameters :param machine: the SpiNNaker machine object :param placements: the placements object :param machine_graph: the machine graph object :param partition_id: the partition ID to add to the edge :return: machine edge and the LPG vertex """ # pylint: disable=too-many-arguments # locate the LPG that's closest to this vertex machine_lpg = self._find_closest_live_packet_gatherer( machine_vertex, m_lpgs, machine, placements) # add edge for the machine graph machine_edge = MachineEdge(machine_vertex, machine_lpg) machine_graph.add_edge(machine_edge, partition_id) # return the machine edge return machine_edge, machine_lpg
def test_virtual_vertices_spreader(): """ Test that the placer works with a virtual vertex """ # Create a graph with a virtual vertex machine_graph = MachineGraph("Test") virtual_vertex = MachineSpiNNakerLinkVertex( spinnaker_link_id=0, label="Virtual") machine_graph.add_vertex(virtual_vertex) # These vertices are fixed on 0, 0 misc_vertices = list() for i in range(3): misc_vertex = SimpleMachineVertex( resources=ResourceContainer(), constraints=[ ChipAndCoreConstraint(0, 0)], label="Fixed_0_0_{}".format(i)) machine_graph.add_vertex(misc_vertex) misc_vertices.append(misc_vertex) # These vertices are 1-1 connected to the virtual vertex one_to_one_vertices = list() for i in range(16): one_to_one_vertex = SimpleMachineVertex( resources=ResourceContainer(), label="Vertex_{}".format(i)) machine_graph.add_vertex(one_to_one_vertex) edge = MachineEdge(virtual_vertex, one_to_one_vertex) machine_graph.add_edge(edge, "SPIKES") one_to_one_vertices.append(one_to_one_vertex) n_keys_map = DictBasedMachinePartitionNKeysMap() partition = machine_graph.get_outgoing_edge_partition_starting_at_vertex( virtual_vertex, "SPIKES") n_keys_map.set_n_keys_for_partition(partition, 1) # Get and extend the machine for the virtual chip machine = virtual_machine(width=8, height=8) extended_machine = MallocBasedChipIdAllocator()(machine, machine_graph) # Do placements placements = SpreaderPlacer()( machine_graph, extended_machine, n_keys_map, plan_n_timesteps=1000) # The virtual vertex should be on a virtual chip placement = placements.get_placement_of_vertex(virtual_vertex) assert machine.get_chip_at(placement.x, placement.y).virtual # The 0, 0 vertices should be on 0, 0 for vertex in misc_vertices: placement = placements.get_placement_of_vertex(vertex) assert placement.x == placement.y == 0 # The other vertices should *not* be on a virtual chip for vertex in one_to_one_vertices: placement = placements.get_placement_of_vertex(vertex) assert not machine.get_chip_at(placement.x, placement.y).virtual
def test_slices(): unittest_setup() app_edge = ProjectionApplicationEdge(None, None, None) mv0_2 = SimpleMachineVertex(None, None, None, None, Slice(0, 1)) mv2_4 = SimpleMachineVertex(None, None, None, None, Slice(2, 3)) mv4_6 = SimpleMachineVertex(None, None, None, None, Slice(4, 5)) app_edge.remember_associated_machine_edge(MachineEdge(mv0_2, mv2_4)) app_edge.remember_associated_machine_edge(MachineEdge(mv4_6, mv0_2)) app_edge.remember_associated_machine_edge(MachineEdge(mv0_2, mv2_4)) assert app_edge.pre_slices == [Slice(0, 1), Slice(4, 5)] post1 = app_edge.post_slices assert post1 == [Slice(0, 1), Slice(2, 3)] app_edge.remember_associated_machine_edge(MachineEdge(mv0_2, mv0_2)) app_edge.remember_associated_machine_edge(MachineEdge(mv2_4, mv2_4)) assert app_edge.pre_slices == [Slice(0, 1), Slice(2, 3), Slice(4, 5)] post2 = app_edge.post_slices assert post1 == post2 assert id(post1) != id(post2)
def test_routing(self): graph = MachineGraph("Test") set_config("Machine", "down_chips", "1,2:5,4:3,3") machine = virtual_machine(8, 8) placements = Placements() vertices = list() for chip in machine.chips: for processor in chip.processors: if not processor.is_monitor: vertex = SimpleMachineVertex(resources=ResourceContainer()) graph.add_vertex(vertex) placements.add_placement( Placement(vertex, chip.x, chip.y, processor.processor_id)) vertices.append(vertex) for vertex in vertices: graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="Test", pre_vertex=vertex)) for vertex_to in vertices: graph.add_edge(MachineEdge(vertex, vertex_to), "Test") routing_paths = ner_route_traffic_aware(graph, machine, placements) for vertex in vertices: vertices_reached = set() queue = deque() seen_entries = set() placement = placements.get_placement_of_vertex(vertex) partition = graph.get_outgoing_edge_partition_starting_at_vertex( vertex, "Test") entry = routing_paths.get_entry_on_coords_for_edge( partition, placement.x, placement.y) self.assertEqual(entry.incoming_processor, placement.p) queue.append((placement.x, placement.y)) while len(queue) > 0: x, y = queue.pop() entry = routing_paths.get_entry_on_coords_for_edge( partition, x, y) self.assertIsNotNone(entry) chip = machine.get_chip_at(x, y) for p in entry.processor_ids: self.assertIsNotNone(chip.get_processor_with_id(p)) vertex_found = placements.get_vertex_on_processor(x, y, p) vertices_reached.add(vertex_found) seen_entries.add((x, y)) for link_id in entry.link_ids: link = chip.router.get_link(link_id) self.assertIsNotNone(link) dest_x, dest_y = link.destination_x, link.destination_y if (dest_x, dest_y) not in seen_entries: queue.append((dest_x, dest_y)) for vertex_to in vertices: self.assertIn(vertex_to, vertices_reached)
def make_circle(vertices, list_size, front_end): leader = 0 for x in range(0, list_size): if vertices[x] is not None: if x % 16 < 15: #make ring front_end.add_machine_edge_instance( MachineEdge(vertices[x], vertices[x + 1], label=(x)), vertices[x].RING) #direct response channel from vertex to leader if x != leader: front_end.add_machine_edge_instance( MachineEdge(vertices[x], vertices[leader], label=(x)), vertices[x].REPORT) #if this is the leader vertex if x % 16 == 0: for y in range(1, 16): front_end.add_machine_edge_instance( MachineEdge(vertices[leader], vertices[leader + y], label=(y - 1)), vertices[x].COMMAND) if x % 16 == 15: #finish ring front_end.add_machine_edge_instance( MachineEdge(vertices[x], vertices[leader], label=(x)), vertices[x].RING) front_end.add_machine_edge_instance( MachineEdge(vertices[x], vertices[leader], label=(x)), vertices[x].REPORT) leader = leader + 16
def test_get_edges_from_edge(self): """ test getting the edges from a graph mapper from a edge """ vertices = list() edges = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(vertices[1], vertices[1])) sube = MachineEdge(vertices[1], vertices[0]) edges.append(sube) edge = SimpleTestEdge(SimpleTestVertex(10, "pre"), SimpleTestVertex(5, "post")) edge.remember_associated_machine_edge(sube) edge.remember_associated_machine_edge(edges[0]) edges_from_edge = edge.machine_edges self.assertIn(sube, edges_from_edge) self.assertIn(edges[0], edges_from_edge) self.assertNotIn(edges[1], edges_from_edge)
def test_get_edges_from_edge(self): """ test getting the edges from a graph mapper from a edge """ vertices = list() edges = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(vertices[1], vertices[1])) sube = MachineEdge(vertices[1], vertices[0]) edges.append(sube) graph = GraphMapper() edge = SimpleTestEdge(SimpleTestVertex(10, "pre"), SimpleTestVertex(5, "post")) graph.add_edge_mapping(sube, edge) graph.add_edge_mapping(edges[0], edge) edges_from_edge = graph.get_machine_edges(edge) self.assertIn(sube, edges_from_edge) self.assertIn(edges[0], edges_from_edge) self.assertNotIn(edges[1], edges_from_edge)
def test_add_duplicate_vertex(self): """ testing that adding the same machine vertex twice will cause an error """ vertices = list() edges = list() subv = SimpleMachineVertex(None, "bacon") vertices.append(subv) vertices.append(SimpleMachineVertex(None, "eggs")) vertices.append(subv) edges.append(MachineEdge(vertices[0], vertices[1])) edges.append(MachineEdge(vertices[1], vertices[0])) graph = MachineGraph("foo") with self.assertRaises(PacmanAlreadyExistsException): graph.add_vertices(vertices) graph.add_outgoing_edge_partition( MulticastEdgePartition(vertices[0], "bar")) graph.add_outgoing_edge_partition( MulticastEdgePartition(vertices[1], "bar")) graph.add_edges(edges, "bar")
def setUp(self): self.machine = virtual_machine(8, 8) self.mach_graph = MachineGraph("machine") self.vertices = list() self.vertex1 = T_MachineVertex(0, 1, get_resources_used_by_atoms(0, 1, []), "First vertex") self.vertex2 = T_MachineVertex(1, 5, get_resources_used_by_atoms(1, 5, []), "Second vertex") self.vertex3 = T_MachineVertex(5, 10, get_resources_used_by_atoms(5, 10, []), "Third vertex") self.vertex4 = T_MachineVertex( 10, 100, get_resources_used_by_atoms(10, 100, []), "Fourth vertex") self.vertices.append(self.vertex1) self.mach_graph.add_vertex(self.vertex1) self.vertices.append(self.vertex2) self.mach_graph.add_vertex(self.vertex2) self.vertices.append(self.vertex3) self.mach_graph.add_vertex(self.vertex3) self.vertices.append(self.vertex4) self.mach_graph.add_vertex(self.vertex4) self.edges = list() edge1 = MachineEdge(self.vertex2, self.vertex3) self.edges.append(edge1) self.mach_graph.add_edge(edge1, "packet") edge2 = MachineEdge(self.vertex2, self.vertex4) self.edges.append(edge2) self.mach_graph.add_edge(edge2, "packet") edge3 = MachineEdge(self.vertex3, self.vertex4) self.edges.append(edge3) self.mach_graph.add_edge(edge3, "packet") edge4 = MachineEdge(self.vertex3, self.vertex1) self.edges.append(edge4) self.plan_n_timesteps = 100
def test_new_graph(self): """ tests that after building a machine graph, all partitined vertices and partitioned edges are in existence """ vertices = list() edges = list() for i in range(10): vertices.append(SimpleMachineVertex(None, "")) for i in range(5): edges.append(MachineEdge(vertices[0], vertices[(i + 1)])) for i in range(5, 10): edges.append(MachineEdge(vertices[5], vertices[(i + 1) % 10])) graph = MachineGraph("foo") graph.add_vertices(vertices) graph.add_edges(edges, "bar") outgoing = set(graph.get_edges_starting_at_vertex(vertices[0])) for i in range(5): assert edges[i] in outgoing, \ "edges[" + str(i) + "] is not in outgoing and should be" for i in range(5, 10): assert edges[i] not in outgoing, \ "edges[" + str(i) + "] is in outgoing and shouldn't be" incoming = set(graph.get_edges_ending_at_vertex(vertices[0])) assert edges[9] in incoming, \ "edges[9] is not in incoming and should be" for i in range(9): assert edges[i] not in incoming, \ "edges[" + str(i) + "] is in incoming and shouldn't be" vertices_from_graph = list(graph.vertices) for vert in vertices_from_graph: self.assertIn(vert, vertices) edges_from_graph = list(graph.edges) for edge in edges_from_graph: self.assertIn(edge, edges)
def test_add_duplicate_edge(self): """ test that adding the same machine edge will cause an error """ vertices = list() edges = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) edge = MachineEdge(vertices[0], vertices[1]) edges.append(edge) edges.append(edge) graph = MachineGraph("foo") graph.add_vertices(vertices) graph.add_edges(edges, "bar")
def test_get_edge_from_machine_edge(self): """ test that tests getting a edge from a graph mapper """ vertices = list() vertices.append(SimpleMachineVertex(None, "")) vertices.append(SimpleMachineVertex(None, "")) edge = SimpleTestEdge(SimpleTestVertex(10, "pre"), SimpleTestVertex(5, "post")) edges = list() edges.append(MachineEdge(vertices[0], vertices[1], app_edge=edge)) edges.append(MachineEdge(vertices[1], vertices[1])) sube = MachineEdge(vertices[1], vertices[0], app_edge=edge) edges.append(sube) edge.remember_associated_machine_edge(sube) edge.remember_associated_machine_edge(edges[0]) self.assertEqual(sube.app_edge, edge) self.assertEqual(edges[0].app_edge, edge) self.assertIsNone(edges[1].app_edge)
def _process_mach_graph_vertex(self, vertex, machine_graph): """ Inserts edges as required for a given vertex :param ExtraMonitorSupportMachineVertex vertex: the extra monitor core :param ~.MachineGraph machine_graph: machine graph object, which is not associated with any application graph :rtype: None """ gatherer = self._get_gatherer_vertex(vertex) # locate if edge is already built; if not, build it and do mapping if not self.__has_edge_already(vertex, gatherer, machine_graph): edge = MachineEdge(vertex, gatherer, traffic_type=DataSpeedUp.TRAFFIC_TYPE) machine_graph.add_edge(edge, PARTITION_ID_FOR_MULTICAST_DATA_SPEED_UP)