def setup(self): self.substrate = datamodel.Substrate("paper_example_substrate") self.substrate.add_node("u", ["universal"], {"universal": 1000}, {"universal": 0.0}) self.substrate.add_node("v", ["universal"], {"universal": 1000}, {"universal": 0.0}) self.substrate.add_node("w", ["universal"], {"universal": 1000}, {"universal": 0.0}) self.substrate.add_edge("u", "v", capacity=1000, bidirected=False) self.substrate.add_edge("v", "w", capacity=1000, bidirected=False) self.substrate.add_edge("w", "u", capacity=1000, bidirected=False) self.request = datamodel.Request("paper_example_request") self.request.add_node("i", 0.0, "universal", ["w"]) self.request.add_node("j", 0.0, "universal", ["v", "w"]) self.request.add_node("k", 0.0, "universal", ["u"]) self.request.add_node("l", 0.0, "universal", ["u", "w"]) self.request.add_node("m", 0.0, "universal", ["u", "v"]) self.request.add_node("n", 0.0, "universal", ["u", "v"]) self.request.add_node("p", 0.0, "universal", ["v"]) self.request.add_node("q", 0.0, "universal", ["u", "w"]) self.request.add_edge("i", "j", 0.0) self.request.add_edge("j", "k", 0.0) self.request.add_edge("k", "l", 0.0) self.request.add_edge("l", "m", 0.0) self.request.add_edge("m", "j", 0.0) self.request.add_edge("m", "p", 0.0) self.request.add_edge("p", "n", 0.0) self.request.add_edge("p", "q", 0.0) self.request.graph["root"] = "j" self.single_edge_sub = datamodel.Substrate("simple_substrate") self.single_edge_sub.add_node("u", ["universal"], {"universal": 1000}, {"universal": 0.0}) self.single_edge_sub.add_node("v", ["universal"], {"universal": 1000}, {"universal": 0.0}) self.single_edge_sub.add_edge("u", "v", capacity=1000, bidirected=False) self.simple_cycle_req = datamodel.Request("simple_cycle_request") self.simple_cycle_req.add_node("i", 0.0, "universal", ["u"]) self.simple_cycle_req.add_node("j", 0.0, "universal", ["v"]) self.simple_cycle_req.add_node("k", 0.0, "universal", ["w"]) self.simple_cycle_req.add_edge("i", "j", 0.0) self.simple_cycle_req.add_edge("j", "k", 0.0) self.simple_cycle_req.add_edge("k", "i", 0.0) self.simple_cycle_req.graph["root"] = "i" self.single_edge_req = datamodel.Request("simple_path_request") self.single_edge_req.add_node("i", 0.0, "universal", ["u", "w"]) self.single_edge_req.add_node("j", 0.0, "universal", ["w", "v"]) self.single_edge_req.add_edge("i", "j", 0.0) self.single_edge_req.graph["root"] = "i"
def setup(self): scenariogeneration.random.seed(5) self.substrate = datamodel.Substrate("paper_example_substrate") self.substrate.add_node("u", ["universal"], {"universal": 10}, {"universal": 0.8}) self.substrate.add_node("v", ["universal"], {"universal": 10}, {"universal": 1.2}) self.substrate.add_node("w", ["universal"], {"universal": 10}, {"universal": 1.0}) self.substrate.add_edge("u", "v", capacity=100, bidirected=False) self.substrate.add_edge("v", "w", capacity=100, bidirected=False) self.substrate.add_edge("w", "u", capacity=100, bidirected=False) self.request = datamodel.Request("test") self.request.add_node("i", 0.33, "universal", ["w"]) self.request.add_node("j", 0.33, "universal", ["v", "w"]) self.request.add_node("k", 0.33, "universal", ["u"]) self.request.add_node("l", 0.33, "universal", ["u", "w"]) self.request.add_node("m", 0.33, "universal", ["u", "v"]) self.request.add_node("n", 0.33, "universal", ["u", "v"]) self.request.add_node("p", 0.33, "universal", ["v"]) self.request.add_node("q", 0.33, "universal", ["u", "w"]) self.request.add_edge("i", "j", 0.25) self.request.add_edge("j", "k", 0.25) self.request.add_edge("k", "l", 0.25) self.request.add_edge("l", "m", 0.25) self.request.add_edge("m", "j", 0.25) self.request.add_edge("m", "p", 0.25) self.request.add_edge("p", "n", 0.25) self.request.add_edge("p", "q", 0.25) self.request.profit = 1000.0 self.request.graph["root"] = "j" scenariogeneration.random.seed(0) self.sg = scenariogeneration.ScenarioGenerator("test")
def test_exclude_edge_mappings_with_insufficient_resources(self): sub = datamodel.Substrate("paper_example_substrate") sub.add_node("u", ["universal"], {"universal": 100}, {"universal": 0.0}) sub.add_node("v", ["universal"], {"universal": 100}, {"universal": 0.0}) sub.add_node("w", ["universal"], {"universal": 100}, {"universal": 0.0}) sub.add_edge("u", "v", capacity=1, bidirected=False) sub.add_edge("v", "w", capacity=1000, bidirected=False) sub.add_edge("w", "u", capacity=1000, bidirected=False) req = datamodel.Request("test") req.add_node("n1", 0.0, "universal", ["u"]) req.add_node("n2", 0.0, "universal", ["v"]) req.add_node("n3", 0.0, "universal", ["w"]) req.add_edge("n1", "n2", 10.0) req.add_edge("n2", "n3", 0.0) req.graph["root"] = "n1" insufficient_ext_edge = (ExtendedCactusGraph._super_node_name( ("n1", "n2"), "u", "layer"), ExtendedCactusGraph._super_node_name( ("n1", "n2"), "v", "layer")) ok_ext_edge = (ExtendedCactusGraph._super_node_name(("n2", "n3"), "u", "layer"), ExtendedCactusGraph._super_node_name(("n2", "n3"), "v", "layer")) eg = ExtendedCactusGraph(req, sub) assert insufficient_ext_edge not in eg.edges, "Extended graph contained edge corresponding to infeasible edge mapping!" assert ok_ext_edge in eg.edges, "Extended graph did not contain edge corresponding to feasible edge mapping!"
def create_test_request(request_id, reverse_edges=None, set_allowed_nodes=True): """ :param request_id: :param reverse_edges: set of edges that should be reversed if they are contained in the original request. :return: """ if reverse_edges is None: reverse_edges = set() request_dict = example_requests[request_id] request = datamodel.Request("{}_req".format(request_id.replace(" ", "_"))) for node in request_dict["nodes"]: allowed = ["u", "v", "w"] if "assumed_allowed_nodes" in request_dict: allowed = request_dict["assumed_allowed_nodes"][node] if set_allowed_nodes: request.add_node(node, 1, "test_type", allowed_nodes=allowed) else: request.add_node(node, 1, "test_type") for edge in request_dict["edges"]: if edge in reverse_edges: edge = edge[1], edge[0] request.add_edge(edge[0], edge[1], 1) return request
def test_decomposition_can_handle_splitting_flows(self): req = datamodel.Request("test_req") req.add_node("root", 1.0, "t1", allowed_nodes=["w"]) req.add_node("n2", 1.0, "t1", allowed_nodes=["v", "w"]) req.add_node("n3", 1.0, "t1", allowed_nodes=["u"]) req.add_edge("root", "n2", 1.0) req.add_edge("root", "n3", 1.0) req.add_edge("n2", "n3", 1.0) req.graph["root"] = "root" sub = datamodel.Substrate("test_sub") sub.add_node("u", ["t1"], {"t1": 100}, {"t1": 100}) sub.add_node("v", ["t1"], {"t1": 100}, {"t1": 100}) sub.add_node("w", ["t1"], {"t1": 100}, {"t1": 100}) sub.add_edge("u", "v", 1000.0, bidirected=True) sub.add_edge("v", "w", 1000.0, bidirected=True) sub.add_edge("w", "u", 1000.0, bidirected=True) # this is a simple request with a splitting flow that caused 200+ mappings due to a bug flow_values = { 'node': { 'root': { 'w': 0.5652934510902061 }, 'n3': { 'u': 0.565293451090206 } }, 'embedding': 0.5652934510902061, 'edge': { ('v_[n2n3]_[u]', 'u_[n2n3]_[u]'): 0.5625924430120608, ('w_[n2n3]_[u]', 'v_[n2n3]_[u]'): 0.16087557584604475, ('u_[rootn3]_[u]', 'u_[n3]_-'): 0.5652934510902061, ('v_[rootn2]_[u]', 'v_[n2n3]_[u]'): 0.40171686716601607, ('w_[root]_+', 'w_[rootn2]_[u]'): 0.5652934510902061, ('w_[rootn2]_[u]', 'v_[rootn2]_[u]'): 0.40171686716601607, ('w_[rootn3]_[u]', 'u_[rootn3]_[u]'): 0.5652934510902061, ('w_[root]_+', 'w_[rootn3]_[u]'): 0.5652934510902061, ('w_[n2n3]_[u]', 'u_[n2n3]_[u]'): 0.00270100807814525, ('w_[rootn2]_[u]', 'w_[n2n3]_[u]'): 0.16357658392419, ('u_[n2n3]_[u]', 'u_[n3]_-'): 0.565293451090206 } } decomposition = modelcreator_ecg_decomposition.Decomposition( req, sub, flow_values, 0.0001, 0.0001, 1e-10) mappings = decomposition.compute_mappings() assert len(mappings) == 3 expected_flow_values = { 0.40171686716601607, 0.16087557584604475, 0.00270100807814525 } for m, flow, load in mappings: best_matching_value = min( (expected for expected in expected_flow_values), key=lambda expected: abs(expected - flow)) expected_flow_values.remove(best_matching_value) assert flow == pytest.approx(best_matching_value, rel=0.001)
def setup(self): self.substrate = datamodel.Substrate("sub1") self.request = datamodel.Request("req1") self.scenario = datamodel.Scenario("Sen1", self.substrate, [self.request]) self.mapping = solutions.Mapping("map1", self.request, self.substrate, True) self.scenariosolution = solutions.IntegralScenarioSolution( "Solution1", self.scenario)
def triangle_request(): req = datamodel.Request("test_req") req.add_node(i, 1.0, "t1", [u]) req.add_node(j, 1.0, "t1", [v]) req.add_node(k, 1.0, "t1", [u, v]) req.add_edge(i, j, 1.0, None) req.add_edge(j, k, 1.0, None) req.add_edge(i, k, 1.0, None) req.graph["root"] = i return req
def test_multiple_compenents_raise_exception(self): request = datamodel.Request("foo") request.add_node("i1", 1, "universal", {"u"}) request.add_node("i2", 1, "universal", {"u"}) request.add_node("i3", 1, "universal", {"u"}) request.add_node("i4", 1, "universal", {"u"}) request.add_edge("i1", "i2", 1) request.add_edge("i3", "i4", 1) with pytest.raises(ExtendedCactusGraphError) as excinfo: ExtendedCactusGraph(request, self.substrate) assert excinfo.match("Request graph may have multiple components:")
def _initialize_bfs_request(self): self.bfs_request = datamodel.Request("{}_bfs".format( self.original_request.name)) for node in self.original_request.nodes: demand = self.original_request.node[node]["demand"] ntype = self.original_request.node[node]["type"] allowed = self.original_request.node[node]["allowed_nodes"] self.bfs_request.add_node(node, demand=demand, ntype=ntype, allowed_nodes=allowed) self._add_bfs_edges_and_initialize_exploration_queue_with_leaf_nodes()
def test_find_node_labels_errors_directed_cycle(): req = datamodel.Request("test_req") req.add_node(i, 1.0, "t1", [u, v]) req.add_node(j, 1.0, "t1", [v, w]) req.add_node(k, 1.0, "t1", [u, w]) req.graph["root"] = i req.add_edge(i, j, 1.0) req.add_edge(j, k, 1.0) req.add_edge(k, i, 1.0) with pytest.raises(commutativity_model.CommutativityModelError) as e: commutativity_model.CommutativityLabels.create_labels(req) assert str(e.value) == "Request is no DAG: cycle contains i, k"
def test_initialize_dag_request_error_with_multiple_components(): req = datamodel.Request("test_req") req.add_node(i, 1.0, "t1", [u, v]) req.add_node(j, 1.0, "t1", [v, w]) req.add_node(k, 1.0, "t1", [u, w]) req.add_node("l", 1.0, "t1", [u, w]) req.graph["root"] = i req.add_edge(i, j, 1.0) req.add_edge(k, "l", 1.0) with pytest.raises(commutativity_model.CommutativityModelError) as e: commutativity_model.CommutativityModelCreator._initialize_dag_request(req) assert str(e.value).startswith("Request graph may have multiple components: Nodes set(['k', 'l']) were not visited by bfs.")
def test_exclude_node_mappings_with_insufficient_resources(self): sub = datamodel.Substrate("paper_example_substrate") sub.add_node("u", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("v", ["t1", "t2"], { "t1": 100, "t2": 0.0 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("w", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_edge("u", "v", capacity=1000, bidirected=False) sub.add_edge("v", "w", capacity=1000, bidirected=False) sub.add_edge("w", "u", capacity=1000, bidirected=False) req = datamodel.Request("test") req.add_node("n1", 10.0, "t1", allowed_nodes=["u"]) req.add_node("n2", 10.0, "t2", allowed_nodes=["v", "w"]) req.add_node("n3", 10.0, "t1", allowed_nodes=["w"]) req.add_edge("n1", "n2", 10.0) req.add_edge("n2", "n3", 0.0) req.graph["root"] = "n1" should_not_exist = (ExtendedCactusGraph._super_node_name( ("n1", "n2"), "v", "layer"), ExtendedCactusGraph._super_node_name("n2", "v", "sink")) should_exist = (ExtendedCactusGraph._super_node_name( ("n1", "n2"), "w", "layer"), ExtendedCactusGraph._super_node_name("n2", "w", "sink")) eg = ExtendedCactusGraph(req, sub) for u in eg.nodes: print u for e in eg.edges: print e assert should_not_exist not in eg.edges, "Extended graph contained edge corresponding to infeasible node mapping in path" assert should_exist in eg.edges, "Extended graph did not contain edge corresponding to feasible node mapping"
def test_find_node_labels_errors_root_with_inneighbors(): req = datamodel.Request("test_req") req.add_node(i, 1.0, "t1", [u, v]) req.add_node(j, 1.0, "t1", [v, w]) req.add_node(k, 1.0, "t1", [u, w]) req.add_node("l", 1.0, "t1", [u, w]) req.graph["root"] = i req.add_edge(i, j, 1.0) req.add_edge("l", i, 1.0) req.add_edge(i, k, 1.0) req.add_edge(k, j, 1.0) with pytest.raises(commutativity_model.CommutativityModelError) as e: commutativity_model.CommutativityLabels.create_labels(req) assert str(e.value) == "Root node i has in-neighbors ['l']"
def test_find_node_labels_errors_two_root_nodes(): req = datamodel.Request("test_req") req.add_node(i, 1.0, "t1", [u, v]) req.add_node(j, 1.0, "t1", [v, w]) req.add_node(k, 1.0, "t1", [u, w]) req.add_node("l", 1.0, "t1", [u, w]) req.graph["root"] = i req.add_edge(i, j, 1.0) req.add_edge(i, "l", 1.0) req.add_edge(k, j, 1.0) req.add_edge(k, "l", 1.0) with pytest.raises(commutativity_model.CommutativityModelError) as e: commutativity_model.CommutativityLabels.create_labels(req) assert str(e.value) == "Node k has no parents, but is not root (root is i). May have multiple components or not be rooted"
def create_large_request(num_nodes, sub, topology): if num_nodes > 26: num_nodes = 26 reverse_edges = set() request_dict = example_requests[topology] request = datamodel.Request("{}_req".format(topology.replace(" ", "_"))) for node in request_dict["nodes"]: allowed = sub.nodes if "assumed_allowed_nodes" in request_dict: allowed = request_dict["assumed_allowed_nodes"][node] request.add_node(node, 1, "test_type", allowed_nodes=allowed) for edge in request_dict["edges"]: if edge in reverse_edges: edge = edge[1], edge[0] request.add_edge(edge[0], edge[1], 1) return request
def test_get_valid_substrate_nodes(substrate): req = datamodel.Request("test_req") req.add_node(i, 1.0, "t1", [u, v]) req.add_node(j, 1.0, "t1", [v, w]) req.add_node(k, 1.0, "t1", [u, w]) _get_valid_substrate_nodes = commutativity_model.CommutativityModelCreator._get_valid_substrate_nodes.__func__ class MockModelCreator(object): pass mmc = MockModelCreator() mmc.substrate = datamodel.SubstrateX(substrate) assert (_get_valid_substrate_nodes(mmc, req, {i, j, k}) == { i: {u, v}, j: {v, w}, k: {u, w}, })
def get_clique_request(number_of_nodes, name="test_request", demand=1.0): """ Generate a complete graph as a single request. :param number_of_nodes: :param name: :param demand: :return: """ test_request = datamodel.Request(name) for i in range(1, number_of_nodes + 1): test_request.add_node("{}_node_{}".format(name, i), demand, scenariogeneration.UNIVERSAL_NODE_TYPE) for i in range(1, number_of_nodes + 1): for j in range(i + 1, number_of_nodes + 1): test_request.add_edge("{}_node_{}".format(name, i), "{}_node_{}".format(name, j), demand) return test_request
def test_bug_request(self): req = datamodel.Request("test") req.add_node("n1", 0.0, "universal", ["u", "w"]) req.add_node("n2", 0.0, "universal", ["u", "w"]) req.add_node("n3", 0.0, "universal", ["u", "w"]) req.add_node("n4", 0.0, "universal", ["u", "w"]) req.add_node("n5", 0.0, "universal", ["u", "w"]) req.add_node("n6", 0.0, "universal", ["u", "w"]) req.add_node("n7", 0.0, "universal", ["u", "w"]) req.add_edge("n1", "n2", 0.0) req.add_edge("n2", "n3", 0.0) req.add_edge("n3", "n7", 0.0) req.add_edge("n3", "n6", 0.0) req.add_edge("n2", "n4", 0.0) req.add_edge("n4", "n5", 0.0) req.add_edge("n5", "n6", 0.0) req.graph["root"] = "n1" eg = ExtendedCactusGraph(req, self.substrate)
def _initialize_dag_request(cls, req): """ Create a DAG request for the request. :param req: the request :return: a rooted DAG request """ dag_request = datamodel.Request("{}_dag".format(req.name)) for node in req.nodes: demand = req.get_node_demand(node) ntype = req.get_type(node) allowed = req.get_allowed_nodes(node) dag_request.add_node(node, demand=demand, ntype=ntype, allowed_nodes=allowed) cls._add_dag_edges_and_initialize_exploration_queue_with_leaf_nodes( req, dag_request) return dag_request
def create_test_request(request_id, test_substrate, reversed_edges=None, allowed_nodes=None, allowed_edges=None, node_types=None, node_demands=None, edge_demands=None): if reversed_edges is None: reversed_edges = set() if allowed_nodes is None: allowed_nodes = {} if allowed_edges is None: allowed_edges = {} if node_types is None: node_types = {} if node_demands is None: node_demands = {} if edge_demands is None: edge_demands = {} req_nodes = REQUEST_TOPOLOGIES[request_id]["nodes"] req_edges = REQUEST_TOPOLOGIES[request_id]["edges"] request = datamodel.Request("{}_req".format(request_id.replace(" ", "_"))) for i in req_nodes: i_type = node_types.get(i, "t") i_demand = node_demands.get(i, 1.0) i_allowed_nodes = allowed_nodes.get(i, set(test_substrate.nodes)) request.add_node(i, demand=i_demand, ntype=i_type, allowed_nodes=i_allowed_nodes) for ij in req_edges: if ij in reversed_edges: ij = ij[1], ij[0] ij_demand = edge_demands.get(ij, 1.0) ij_allowed = allowed_edges.get(ij) request.add_edge(ij[0], ij[1], ij_demand, allowed_edges=ij_allowed) return request
def generate_random_request_graph(size, prob, req_name="test_req", substrate_nodes=(u, v, w)): req = datamodel.Request(req_name) for i in range(1, size + 1): node = "{}".format(i) neighbors = [] for j in req.nodes: if random.random() <= prob: neighbors.append(j) req.add_node( node, 1.0, "t1", random.sample(substrate_nodes, random.randrange(1, len(substrate_nodes)))) for j in neighbors: req.add_edge(j, node, 1.0) visited = set() all_nodes = set(req.nodes) while visited != all_nodes: start_node = (all_nodes - visited).pop() if visited: req.add_edge(random.choice(list(visited)), start_node, 1.0) visited.add(start_node) stack = [start_node] while stack: i = stack.pop() neighbors = req.get_in_neighbors(i) + req.get_out_neighbors(i) for j in neighbors: if j in visited: continue else: stack.append(j) visited.add(j) req.graph["root"] = random.choice(list(req.nodes)) return req
def test_model_fixing_simple_scenario(self): sub = datamodel.Substrate("fixing_sub") sub.add_node("u", {"t1"}, {"t1": 10}, {"t1": 100}) sub.add_node("v", {"t1"}, {"t1": 10}, {"t1": 100}) sub.add_node("w", {"t1"}, {"t1": 10}, {"t1": 100}) sub.add_node("x", {"t1"}, {"t1": 10}, {"t1": 100}) sub.add_edge("u", "v") sub.add_edge("v", "w") sub.add_edge("w", "x") sub.add_edge("x", "u") req = datamodel.Request("fixing_req") req.profit = 1000 req.add_node("i", 5, "t1", {"u", "v", "w", "x"}) req.add_node("j", 5, "t1", {"u", "v", "w", "x"}) req.add_edge("i", "j", 0.5) mapping = solutions.Mapping("fixing_mapping", req, sub, True) mapping.map_node("i", "u") mapping.map_node("j", "x") mapping.map_edge(("i", "j"), [("u", "v"), ("v", "w"), ("w", "x")]) scenario = datamodel.Scenario("fixing_scen", sub, [req], datamodel.Objective.MAX_PROFIT) sol = solutions.IntegralScenarioSolution("fixing_sol", scenario) sol.add_mapping(req, mapping) mc_ecg = modelcreator_ecg_decomposition.ModelCreatorCactusDecomposition( scenario) mc_ecg.init_model_creator() mc_ecg.fix_mapping_variables_according_to_integral_solution(sol) ecg_sol = mc_ecg.compute_integral_solution() new_mapping = ecg_sol.solution.request_mapping[req] assert new_mapping.mapping_nodes == mapping.mapping_nodes assert new_mapping.mapping_edges == mapping.mapping_edges
def setup(self): self.substrate = datamodel.Substrate("sub1") self.request = datamodel.Request("req1") self.scenario = datamodel.Scenario("Sen1", self.substrate, [self.request])
def setup(self): self.request = datamodel.Request("req1")
def test_handmade_example_containing_multiple_mappings(self): req = datamodel.Request("test_req") req.add_node("i", 1.0, "t1", allowed_nodes=["w"]) req.add_node("j", 1.0, "t1", allowed_nodes=["v", "w"]) req.add_node("k", 1.0, "t1", allowed_nodes=["u"]) req.add_node("l", 1.0, "t1", allowed_nodes=["u", "v"]) req.add_edge("i", "j", 1.0) req.add_edge("j", "k", 1.0) req.add_edge("i", "k", 1.0) req.add_edge("j", "l", 1.0) req.graph["root"] = "i" sub = datamodel.Substrate("test_sub") sub.add_node("u", ["t1"], {"t1": 100}, {"t1": 100}) sub.add_node("v", ["t1"], {"t1": 100}, {"t1": 100}) sub.add_node("w", ["t1"], {"t1": 100}, {"t1": 100}) sub.add_edge("u", "v", 1000.0, bidirected=True) sub.add_edge("v", "w", 1000.0, bidirected=True) sub.add_edge("w", "u", 1000.0, bidirected=True) ext_graph = extendedcactusgraph.ExtendedCactusGraph(req, sub) # print util.get_graph_viz_string(ext_graph) # print "\n".join(str(e) for e in ext_graph.nodes) # print "\n".join(str(e) for e in ext_graph.edges) flow_values = { 'embedding': 1.0, 'node': { 'i': { 'w': 1.0 }, 'j': { 'v': 0.5, 'w': 0.5 }, 'k': { 'u': 1.0 }, 'l': { 'v': 0.5, 'u': 0.5 } }, 'edge': { ('w_[i]_+', 'w_[ij]_[u]'): 1.0, ('w_[ij]_[u]', 'w_[jk]_[u]'): 0.5, ('w_[ij]_[u]', 'v_[ij]_[u]'): 0.5, ('v_[ij]_[u]', 'v_[jk]_[u]'): 0.5, ('v_[jk]_[u]', 'u_[jk]_[u]'): 0.5, ('w_[jk]_[u]', 'u_[jk]_[u]'): 0.5, ('u_[jk]_[u]', 'u_[k]_-'): 1.0, ('v_[j]_+', 'v_[jl]'): 0.5, ('w_[j]_+', 'w_[jl]'): 0.5, ('v_[jl]', 'v_[l]_-'): 0.5, ('w_[jl]', 'u_[jl]'): 0.5, ('u_[jl]', 'u_[l]_-'): 0.5, ('w_[i]_+', 'w_[ik]_[u]'): 1.0, ('w_[ik]_[u]', 'u_[ik]_[u]'): 1.0, ('u_[ik]_[u]', 'u_[k]_-'): 1.0, } } decomposition = modelcreator_ecg_decomposition.Decomposition( req, sub, flow_values, 0.0001, 0.0001, 1e-10) mappings = decomposition.compute_mappings() assert len(mappings) == 2 expected_flow_values = [0.5, 0.5] for m, flow, load in mappings: best_matching_value = min( (expected for expected in expected_flow_values), key=lambda expected: abs(expected - flow)) expected_flow_values.remove(best_matching_value) assert flow == pytest.approx(best_matching_value)
def test_exclude_node_mappings_with_insufficient_resources_cycle(self): # check for a cycle sub = datamodel.Substrate("test_substrate") sub.add_node("u", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("v", ["t1", "t2"], { "t1": 100, "t2": 0.0 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("w", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("x", ["t1"], {"t1": 1.0}, {"t1": 0.0}) sub.add_edge("u", "v", capacity=1000, bidirected=False) sub.add_edge("v", "w", capacity=1000, bidirected=False) sub.add_edge("w", "u", capacity=1000, bidirected=False) sub.add_edge("w", "x", capacity=1000, bidirected=False) req = datamodel.Request("test_request") req.graph["root"] = "n1" req.add_node("n1", 10.0, "t1", allowed_nodes=["u"]) req.add_node("n2", 10.0, "t2", allowed_nodes=["v", "w"]) req.add_node("n3", 10.0, "t1", allowed_nodes=["w"]) req.add_node("target", 10.0, "t1", allowed_nodes=["w", "x"]) req.add_edge("n1", "n2", 10.0) req.add_edge("n2", "target", 10.0) req.add_edge("n1", "n3", 10.0) req.add_edge("n3", "target", 10.0) eg = ExtendedCactusGraph(req, sub) should_not_exist = (ExtendedCactusGraph._super_node_name( ("n1", "n2"), "v", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name( ("n2", "target"), "v", "layer_cycle", branch_substrate_node="w")) should_exist = (ExtendedCactusGraph._super_node_name( ("n1", "n2"), "w", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name( ("n2", "target"), "w", "layer_cycle", branch_substrate_node="w")) print should_not_exist print should_exist for u in eg.nodes: print u for e in eg.edges: print e assert should_exist in eg.edges, "Extended graph did not contain edge corresponding to feasible node mapping" assert should_not_exist not in eg.edges, "Extended graph contained edge corresponding to infeasible node mapping in cycle" should_not_exist = ExtendedCactusGraph._super_node_name( ("n1", "n2"), "v", "layer_cycle", branch_substrate_node="x") should_exist = ExtendedCactusGraph._super_node_name( ("n1", "n2"), "v", "layer_cycle", branch_substrate_node="w") assert should_not_exist not in eg.nodes, "Extended graph contained edge corresponding to infeasible node mapping in cycle"
def test_exclude_edge_mappings_with_insufficient_resources_cycle(self): sub = datamodel.Substrate("test_substrate") sub.add_node("u", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("v", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_node("w", ["t1", "t2"], { "t1": 100, "t2": 100 }, { "t1": 0.0, "t2": 0.0 }) sub.add_edge("w", "u", capacity=10.0, bidirected=False) sub.add_edge("v", "w", capacity=50.0, bidirected=False) sub.add_edge("u", "v", capacity=100.0, bidirected=False) req = datamodel.Request("test_request") req.graph["root"] = "n1" req.add_node("n1", 10.0, "t1", allowed_nodes=["u", "v", "w"]) req.add_node("n2", 10.0, "t2", allowed_nodes=["u", "v", "w"]) req.add_node("n3", 10.0, "t1", allowed_nodes=["w"]) req.add_edge("n1", "n2", 1.0) req.add_edge("n2", "n3", 50.0) req.add_edge("n1", "n3", 100.0) eg = ExtendedCactusGraph(req, sub) from alib.util import get_graph_viz_string print get_graph_viz_string(eg) should_not_exist = [ (ExtendedCactusGraph._super_node_name(("n2", "n3"), "w", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name(("n2", "n3"), "u", "layer_cycle", branch_substrate_node="w")), (ExtendedCactusGraph._super_node_name(("n1", "n3"), "w", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name(("n1", "n3"), "u", "layer_cycle", branch_substrate_node="w")), (ExtendedCactusGraph._super_node_name(("n1", "n3"), "v", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name(("n1", "n3"), "w", "layer_cycle", branch_substrate_node="w")), ] should_exist = [ (ExtendedCactusGraph._super_node_name(("n2", "n3"), "u", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name(("n2", "n3"), "v", "layer_cycle", branch_substrate_node="w")), (ExtendedCactusGraph._super_node_name(("n2", "n3"), "v", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name(("n2", "n3"), "w", "layer_cycle", branch_substrate_node="w")), (ExtendedCactusGraph._super_node_name(("n1", "n3"), "u", "layer_cycle", branch_substrate_node="w"), ExtendedCactusGraph._super_node_name(("n1", "n3"), "v", "layer_cycle", branch_substrate_node="w")), ] for e in should_exist: assert e in eg.edges for e in should_not_exist: assert e not in eg.edges