def test_call(self): """ Test calling the binary gatherer normally """ vertex_1 = _TestVertexWithBinary("test.aplx", ExecutableType.RUNNING) vertex_2 = _TestVertexWithBinary("test2.aplx", ExecutableType.RUNNING) vertex_3 = _TestVertexWithBinary("test2.aplx", ExecutableType.RUNNING) vertex_4 = _TestVertexWithoutBinary() graph = MachineGraph("Test") graph.add_vertices([vertex_1, vertex_2, vertex_3]) placements = Placements(placements=[ Placement(vertex_1, 0, 0, 0), Placement(vertex_2, 0, 0, 1), Placement(vertex_3, 0, 0, 2), Placement(vertex_4, 0, 0, 3) ]) gatherer = GraphBinaryGatherer() targets = gatherer.__call__(placements, graph, _TestExecutableFinder()) gatherer = LocateExecutableStartType() start_type = gatherer.__call__(graph, placements) self.assertEqual(next(iter(start_type)), ExecutableType.RUNNING) self.assertEqual(targets.total_processors, 3) test_cores = targets.get_cores_for_binary("test.aplx") test_2_cores = targets.get_cores_for_binary("test2.aplx") self.assertEqual(len(test_cores), 1) self.assertEqual(len(test_2_cores), 2) self.assertIn((0, 0, 0), test_cores) self.assertIn((0, 0, 1), test_2_cores) self.assertIn((0, 0, 2), test_2_cores)
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 test_none_have_app_vertex(self): app_graph = ApplicationGraph("Test") graph = MachineGraph("foo", app_graph) app1 = SimpleTestVertex(12, "app1") mach1 = SimpleMachineVertex("mach1", app_vertex=None) mach2 = SimpleMachineVertex("mach2", app_vertex=None) mach3 = SimpleMachineVertex("mach3", app_vertex=app1) graph.add_vertices([mach1, mach2]) with self.assertRaises(PacmanInvalidParameterException): graph.add_vertex(mach3)
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_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 test_mixed_binaries(self): """ Test calling the binary gatherer with mixed executable types """ vertex_1 = _TestVertexWithBinary("test.aplx", ExecutableStartType.RUNNING) vertex_2 = _TestVertexWithBinary("test2.aplx", ExecutableStartType.SYNC) graph = MachineGraph("Test") graph.add_vertices([vertex_1, vertex_2]) gatherer = LocateExecutableStartType() with self.assertRaises(ConfigurationException): gatherer.__call__(graph)
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 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 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_outgoing_edge_partition( MulticastEdgePartition(vertices[0], "bar")) with self.assertRaises(PacmanAlreadyExistsException): graph.add_edges(edges, "bar")
def test_remember_machine_vertex(self): app_graph = ApplicationGraph("Test") graph = MachineGraph("foo", app_graph) app1 = SimpleTestVertex(12, "app1") app2 = SimpleTestVertex(12, "app2") mach1 = SimpleMachineVertex("mach1", app_vertex=app1) mach2 = SimpleMachineVertex("mach2", app_vertex=app1) mach3 = SimpleMachineVertex("mach3", app_vertex=app1) mach4 = SimpleMachineVertex("mach4", app_vertex=app2) self.assertEquals(0, len(app1.machine_vertices)) self.assertEquals(0, len(app2.machine_vertices)) graph.add_vertices([mach1, mach2]) graph.add_vertex(mach3) graph.add_vertex(mach4) self.assertEquals(3, len(app1.machine_vertices)) self.assertEquals(1, len(app2.machine_vertices)) self.assertIn(mach1, app1.machine_vertices) self.assertIn(mach2, app1.machine_vertices) self.assertIn(mach3, app1.machine_vertices) self.assertIn(mach4, app2.machine_vertices)
def test_mixed_binaries(self): """ Test calling the binary gatherer with mixed executable types """ vertex_1 = _TestVertexWithBinary("test.aplx", ExecutableType.RUNNING) vertex_2 = _TestVertexWithBinary("test2.aplx", ExecutableType.SYNC) placements = Placements(placements=[ Placement(vertex_1, 0, 0, 0), Placement(vertex_2, 0, 0, 1) ]) graph = MachineGraph("Test") graph.add_vertices([vertex_1, vertex_2]) gatherer = LocateExecutableStartType() results = gatherer.__call__(graph, placements=placements) self.assertIn(ExecutableType.RUNNING, results) self.assertIn(ExecutableType.SYNC, results) self.assertNotIn(ExecutableType.USES_SIMULATION_INTERFACE, results) self.assertNotIn(ExecutableType.NO_APPLICATION, results)
def test_mixed_binaries(self): """ Test calling the binary gatherer with mixed executable types """ vertex_1 = _TestVertexWithBinary( "test.aplx", ExecutableType.RUNNING) vertex_2 = _TestVertexWithBinary( "test2.aplx", ExecutableType.SYNC) placements = Placements(placements=[ Placement(vertex_1, 0, 0, 0), Placement(vertex_2, 0, 0, 1)]) graph = MachineGraph("Test") graph.add_vertices([vertex_1, vertex_2]) gatherer = LocateExecutableStartType() results = gatherer.__call__(graph, placements=placements) self.assertIn(ExecutableType.RUNNING, results) self.assertIn(ExecutableType.SYNC, results) self.assertNotIn(ExecutableType.USES_SIMULATION_INTERFACE, results) self.assertNotIn(ExecutableType.NO_APPLICATION, results)
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_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_call(self): """ Test calling the binary gatherer normally """ vertex_1 = _TestVertexWithBinary( "test.aplx", ExecutableType.RUNNING) vertex_2 = _TestVertexWithBinary( "test2.aplx", ExecutableType.RUNNING) vertex_3 = _TestVertexWithBinary( "test2.aplx", ExecutableType.RUNNING) vertex_4 = _TestVertexWithoutBinary() graph = MachineGraph("Test") graph.add_vertices([vertex_1, vertex_2, vertex_3]) placements = Placements(placements=[ Placement(vertex_1, 0, 0, 0), Placement(vertex_2, 0, 0, 1), Placement(vertex_3, 0, 0, 2), Placement(vertex_4, 0, 0, 3)]) gatherer = GraphBinaryGatherer() targets = gatherer.__call__( placements, graph, _TestExecutableFinder()) gatherer = LocateExecutableStartType() start_type = gatherer.__call__(graph, placements) self.assertEqual(next(iter(start_type)), ExecutableType.RUNNING) self.assertEqual(targets.total_processors, 3) test_cores = targets.get_cores_for_binary("test.aplx") test_2_cores = targets.get_cores_for_binary("test2.aplx") self.assertEqual(len(test_cores), 1) self.assertEqual(len(test_2_cores), 2) self.assertIn((0, 0, 0), test_cores) self.assertIn((0, 0, 1), test_2_cores) self.assertIn((0, 0, 2), test_2_cores)
def check_new_graph(self, app_graph, app_vertex): """ 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, "", app_vertex=app_vertex)) 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", application_graph=app_graph) graph.add_vertices(vertices) graph.add_outgoing_edge_partition( MulticastEdgePartition(vertices[0], "bar")) graph.add_outgoing_edge_partition( MulticastEdgePartition(vertices[5], "bar")) 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) for vert in vertices: self.assertEqual(vert, graph.vertex_by_label(vert.label)) edges_from_graph = list(graph.edges) for edge in edges_from_graph: self.assertIn(edge, edges) if app_graph: with self.assertRaises(PacmanInvalidParameterException): graph.clone() else: second = graph.clone() self.assertEqual(graph.n_vertices, second.n_vertices) vertices_from_graph = list(second.vertices) for vert in vertices_from_graph: self.assertIn(vert, vertices) for vert in vertices: self.assertEqual(vert, graph.vertex_by_label(vert.label)) self.assertEqual(graph.n_outgoing_edge_partitions, second.n_outgoing_edge_partitions) edges_from_graph = list(second.edges) for edge in edges_from_graph: self.assertIn(edge, edges) self.assertEqual(len(edges_from_graph), len(edges)) third = MachineGraphView(graph) self.assertEqual(graph.n_vertices, third.n_vertices) vertices_from_graph = list(third.vertices) for vert in vertices_from_graph: self.assertIn(vert, vertices) for vert in vertices: self.assertEqual(vert, graph.vertex_by_label(vert.label)) self.assertEqual(graph.n_outgoing_edge_partitions, third.n_outgoing_edge_partitions) edges_from_graph = list(third.edges) for edge in edges_from_graph: self.assertIn(edge, edges) self.assertEqual(len(edges_from_graph), len(edges)) with self.assertRaises(PacmanConfigurationException): third.add_edge("mock", "mock") with self.assertRaises(PacmanConfigurationException): third.add_vertex("mock") with self.assertRaises(PacmanConfigurationException): third.add_outgoing_edge_partition("mock")
def test_at_vertex_methods(self): graph = MachineGraph("foo") mach1 = MockMachineVertex("mach1", sdram_requirement=0) mach2 = MockMachineVertex("mach2", sdram_requirement=0) mach3 = MockMachineVertex("mach3", sdram_requirement=0) mach4 = SimpleMachineVertex("mach4") graph.add_vertices([mach1, mach2, mach3, mach4]) # Add partition then edge part_m_1 = MulticastEdgePartition(mach1, "spikes") graph.add_outgoing_edge_partition(part_m_1) edge_m_11 = MachineEdge(mach1, mach2, traffic_type=EdgeTrafficType.MULTICAST) graph.add_edge(edge_m_11, "spikes") # check clear error it you add the edge again with self.assertRaises(PacmanAlreadyExistsException): graph.add_edge(edge_m_11, "spikes") self.assertIn(edge_m_11, part_m_1.edges) edge_m_12 = MachineEdge(mach1, mach3, traffic_type=EdgeTrafficType.MULTICAST) graph.add_edge(edge_m_12, "spikes") edge_m_21 = MachineEdge(mach3, mach4, traffic_type=EdgeTrafficType.MULTICAST) graph.add_edge(edge_m_21, "spikes") part_m_2 = graph.get_outgoing_partition_for_edge(edge_m_21) edge_f_1 = MachineEdge(mach1, mach3, traffic_type=EdgeTrafficType.FIXED_ROUTE) graph.add_edge(edge_f_1, "Control") part_f = graph.get_outgoing_partition_for_edge(edge_f_1) part_s_1 = ConstantSDRAMMachinePartition("ram", mach1, "ram1") graph.add_outgoing_edge_partition(part_s_1) edge_s_11 = SDRAMMachineEdge(mach1, mach2, "s1") graph.add_edge(edge_s_11, "ram") edge_s_12 = SDRAMMachineEdge(mach1, mach3, "s2") graph.add_edge(edge_s_12, "ram") starting_at_mach1 = list( graph.get_outgoing_edge_partitions_starting_at_vertex(mach1)) self.assertIn(part_m_1, starting_at_mach1) self.assertIn(part_f, starting_at_mach1) self.assertIn(part_s_1, starting_at_mach1) self.assertEqual(3, len(starting_at_mach1)) starting_at_mach3 = list( graph.get_outgoing_edge_partitions_starting_at_vertex(mach3)) self.assertIn(part_m_2, starting_at_mach3) self.assertEqual(1, len(starting_at_mach3)) starting_at_mach4 = list( graph.get_outgoing_edge_partitions_starting_at_vertex(mach4)) self.assertEqual(0, len(starting_at_mach4)) ending_at_mach2 = list( graph.get_edge_partitions_ending_at_vertex(mach2)) self.assertIn(part_m_1, ending_at_mach2) self.assertIn(part_s_1, ending_at_mach2) self.assertEqual(2, len(ending_at_mach2)) ending_at_mach3 = list( graph.get_edge_partitions_ending_at_vertex(mach3)) self.assertIn(part_m_1, ending_at_mach3) self.assertIn(part_f, ending_at_mach3) self.assertIn(part_s_1, ending_at_mach3) self.assertEqual(3, len(ending_at_mach3)) ending_at_mach1 = list( graph.get_edge_partitions_ending_at_vertex(mach1)) self.assertEqual(0, len(ending_at_mach1))