def test_extract_edge_mapping_multiple_start_nodes(substrate, triangle_request):
triangle_request.node[i]["allowed_nodes"] = [u, v]
scenario = datamodel.Scenario("test", substrate, [triangle_request])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
mc.preprocess_input()
mc._create_sub_lp_variables()
ku_index = frozenset([(k, u)])
ij_sub_lp = mc.edge_sub_lp[triangle_request][ij][ku_index]
ij_sub_lp.var_node_flow_source[u].x = 0.3
ij_sub_lp.var_node_flow_source[v].x = 0.7
ij_sub_lp.var_edge_flow[uv].x = 0.3
ij_sub_lp.var_node_flow_sink[v].x = 1.0
partial_mapping = solutions.Mapping("test_mapping", triangle_request, substrate, True)
partial_mapping.map_node(i, u)
assert ij_sub_lp.extract_edge_mapping(partial_mapping) == ([uv], v, 0.3)
partial_mapping = solutions.Mapping("test_mapping", triangle_request, substrate, True)
partial_mapping.map_node(i, v)
assert ij_sub_lp.extract_edge_mapping(partial_mapping) == ([], v, 0.7)
def test_extract_edge_mapping_only_use_exit_with_remaining_node_sink_flow(substrate, triangle_request):
triangle_request.node[j]["allowed_nodes"] = [v, w]
scenario = datamodel.Scenario("test", substrate, [triangle_request])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
mc.preprocess_input()
mc._create_sub_lp_variables()
ku_index = frozenset([(k, u)])
ij_sub_lp = mc.edge_sub_lp[triangle_request][ij][ku_index]
ij_sub_lp.var_node_flow_source[u].x = 1.0
# This contains 3 mappings with values 0.5, 0.25 and 0.25
ij_sub_lp.var_edge_flow[uw].x = 0.5
ij_sub_lp.var_edge_flow[uv].x = 0.5
ij_sub_lp.var_edge_flow[wv].x = 0.25
ij_sub_lp.var_node_flow_sink[w].x = 0.25
ij_sub_lp.var_node_flow_sink[v].x = 0.75
partial_mapping = solutions.Mapping("test_mapping", triangle_request, substrate, True)
partial_mapping.map_node(i, u)
ij_sub_lp._used_flow_source[u] += 0.5
ij_sub_lp._used_flow[uv] += 0.5
ij_sub_lp._used_flow_sink[v] += 0.5
assert ij_sub_lp.extract_edge_mapping(partial_mapping) == ([uw], w, 0.25)
ij_sub_lp._used_flow_source[u] += 0.25
ij_sub_lp._used_flow[uw] += 0.25
ij_sub_lp._used_flow_sink[w] += 0.25
assert ij_sub_lp.extract_edge_mapping(partial_mapping) == ([uw, wv], v, 0.25)
def test_extract_edge_mapping_reversed_edge(substrate, triangle_request):
triangle_request.graph["root"] = j
scenario = datamodel.Scenario("test", substrate, [triangle_request])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
mc.preprocess_input()
mc._create_sub_lp_variables()
ku_index = frozenset([(k, u)])
kv_index = frozenset([(k, v)])
ji_sub_lp = list(mc.edge_sub_lp[triangle_request][("j", "i")].values())[0]
ji_sub_lp.var_node_flow_source[v].x = 0.5
ji_sub_lp.var_edge_flow[wu].x = 0.5
ji_sub_lp.var_edge_flow[vw].x = 0.5
ji_sub_lp.var_node_flow_sink[u].x = 0.5
partial_mapping = solutions.Mapping("test_mapping", triangle_request,
substrate, True)
partial_mapping.map_node(j, v)
assert ji_sub_lp.extract_edge_mapping(partial_mapping) == ([uw,
wv], u, 0.5)
def test_extract_edge_mapping_colocated_nodes(substrate, triangle_request):
scenario = datamodel.Scenario("test", substrate, [triangle_request])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
mc.preprocess_input()
mc._create_sub_lp_variables()
ku_index = frozenset([(k, u)])
ik_sub_lp = mc.edge_sub_lp[triangle_request][ik][ku_index]
ik_sub_lp.var_node_flow_source[u].x = 0.5
ik_sub_lp.var_node_flow_sink[u].x = 0.5
partial_mapping = solutions.Mapping("test_mapping", triangle_request, substrate, True)
partial_mapping.map_node(i, u)
assert ik_sub_lp.extract_edge_mapping(partial_mapping) == ([], u, 0.5)
def test_sublp_inconsistency_causes_exception(substrate, triangle_request):
scenario = datamodel.Scenario("test", substrate, [triangle_request])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
mc.preprocess_input()
mc._create_sub_lp_variables()
ku_index = frozenset([(k, u)])
ij_sub_lp = mc.edge_sub_lp[triangle_request][ij][ku_index]
ij_sub_lp.var_node_flow_source[u].x = 1.0
partial_mapping = solutions.Mapping("", triangle_request, substrate, True)
partial_mapping.mapping_nodes[i] = "u"
with pytest.raises(ValueError) as e:
ij_sub_lp.extract_edge_mapping(partial_mapping)
assert str(e.value) == "Did not find valid edge mapping for ('i', 'j')"
def test_sublp_reduce_flow(substrate, triangle_request):
scenario = datamodel.Scenario("test", substrate, [triangle_request])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
mc.preprocess_input()
mc._create_sub_lp_variables()
ku_index = frozenset([(k, u)])
ij_sub_lp = mc.edge_sub_lp[triangle_request][ij][ku_index]
partial_mapping = solutions.Mapping("test_mapping", triangle_request, substrate, True)
partial_mapping.map_node(i, u)
partial_mapping.map_node(j, v)
partial_mapping.map_edge(ij, [uw, wv])
ij_sub_lp.reduce_flow(partial_mapping, 0.75)
assert ij_sub_lp._used_flow[uw] == 0.75
assert ij_sub_lp._used_flow[wv] == 0.75
assert ij_sub_lp._used_flow_source[u] == 0.75
assert ij_sub_lp._used_flow_sink[v] == 0.75
def test_decomposition_full_request(request_id, substrate):
req = create_request(request_id)
req.graph["root"] = example_requests[request_id]["assumed_root"]
scenario = datamodel.Scenario("test", substrate, [req])
mc = commutativity_model.CommutativityModelCreator(scenario)
mc.model = MockModel("mockmodel")
if example_requests[request_id].get("ignore_bfs", False):
mc.dag_requests[req] = req
mc.preprocess_input()
mc.create_variables()
def node_mapping_var(i, index, u):
return mc.var_node_mapping[req][i][u][index]
def source_var(ij, index, u):
return mc.edge_sub_lp[req][ij][index].var_node_flow_source[u]
def sink_var(ij, index, v):
return mc.edge_sub_lp[req][ij][index].var_node_flow_sink[v]
def edge_var(ij, index, uv):
return mc.edge_sub_lp[req][ij][index].var_edge_flow[uv]
var_type_lookup = dict(node_mapping_var=node_mapping_var,
source_var=source_var,
sink_var=sink_var,
edge_var=edge_var)
expected_mappings = set()
expected_embedding_flow = 0.0
for test_mapping in example_requests[request_id]["mappings"]:
flow = test_mapping["flow"]
expected_embedding_flow += flow
vars = test_mapping["variables"]
expected_mappings.add(
(flow,
frozenset(test_mapping["expected"]["nodes"].items()),
frozenset((k, tuple(v)) for (k, v) in test_mapping["expected"]["edges"].items()))
)
for var_type, req_key, comm_index, substrate_key in vars:
var = var_type_lookup[var_type](req_key, comm_index, substrate_key)
var.x += flow
mc.var_embedding_decision[req].x += flow
frac_sol = mc.recover_fractional_solution_from_variables()
obtained_mappings = set()
for mapping_list in frac_sol.request_mapping.values():
for mapping in mapping_list:
obtained_mappings.add((
frac_sol.mapping_flows[mapping.name],
frozenset(mapping.mapping_nodes.items()),
frozenset((k, tuple(v)) for (k, v) in mapping.mapping_edges.items())
))
assert obtained_mappings == expected_mappings
assert mc._used_flow_embedding_decision[req] == expected_embedding_flow
expected_used_node_flow = {req: {}}
for i, u_comm_index_dict in mc.var_node_mapping[req].items():
expected_used_node_flow[req][i] = {}
for u, comm_index_dict in u_comm_index_dict.items():
expected_used_node_flow[req][i][u] = {}
for comm_index, var in comm_index_dict.items():
expected_used_node_flow[req][i][u][comm_index] = var.x
assert mc._used_flow_node_mapping == expected_used_node_flow
for ij in mc.dag_requests[req].edges:
for comm_index, sub_lp in mc.edge_sub_lp[req][ij].iteritems():
expected_used_source_flow = {
u: var.x for u, var in sub_lp.var_node_flow_source.iteritems()
}
assert sub_lp._used_flow_source == expected_used_source_flow
expected_used_sink_flow = {
u: var.x for u, var in sub_lp.var_node_flow_sink.iteritems()
}
assert sub_lp._used_flow_sink == expected_used_sink_flow
expected_used_edge_flow = {
uv: var.x for uv, var in sub_lp.var_edge_flow.iteritems()
}
assert sub_lp._used_flow == expected_used_edge_flow
