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)
