|
|
import networkx as nx |
|
|
import graphviz as gv |
|
|
from broadcast import * |
|
|
import pandas as pd |
|
|
import time |
|
|
import functools |
|
|
import graphviz as gv |
|
|
|
|
|
|
|
|
GBIT_PER_GBYTE = 8 |
|
|
|
|
|
|
|
|
class Timer: |
|
|
def __init__(self, print_desc=None): |
|
|
self.print_desc = print_desc |
|
|
self.start = time.time() |
|
|
self.end = None |
|
|
|
|
|
def __enter__(self): |
|
|
return self |
|
|
|
|
|
def __exit__(self, exc_typ, exc_val, exc_tb): |
|
|
self.end = time.time() |
|
|
|
|
|
@property |
|
|
def elapsed(self): |
|
|
if self.end is None: |
|
|
end = time.time() |
|
|
return end - self.start |
|
|
else: |
|
|
return self.end - self.start |
|
|
|
|
|
|
|
|
@functools.lru_cache(maxsize=None) |
|
|
def get_path_cost(src, dst, src_tier="PREMIUM", dst_tier="PREMIUM"): |
|
|
from skyplane import compute |
|
|
|
|
|
assert src_tier == "PREMIUM" and dst_tier == "PREMIUM" |
|
|
return compute.CloudProvider.get_transfer_cost(src, dst) |
|
|
|
|
|
|
|
|
def make_nx_graph(cost_path=None, throughput_path=None, num_vms=1): |
|
|
""" |
|
|
Default graph with capacity constraints and cost info |
|
|
nodes: regions, edges: links |
|
|
per edge: |
|
|
throughput: max tput achievable (gbps) |
|
|
cost: $/GB |
|
|
flow: actual flow (gbps), must be < throughput, default = 0 |
|
|
""" |
|
|
if cost_path is None: |
|
|
cost = pd.read_csv("profiles/cost.csv") |
|
|
else: |
|
|
cost = pd.read_csv(cost_path) |
|
|
|
|
|
if throughput_path is None: |
|
|
throughput = pd.read_csv("profiles/throughput.csv") |
|
|
else: |
|
|
throughput = pd.read_csv(throughput_path) |
|
|
|
|
|
G = nx.DiGraph() |
|
|
for _, row in throughput.iterrows(): |
|
|
if row["src_region"] == row["dst_region"]: |
|
|
continue |
|
|
G.add_edge(row["src_region"], row["dst_region"], cost=None, throughput=num_vms * row["throughput_sent"] / 1e9) |
|
|
|
|
|
for _, row in cost.iterrows(): |
|
|
if row["src"] in G and row["dest"] in G[row["src"]]: |
|
|
G[row["src"]][row["dest"]]["cost"] = row["cost"] |
|
|
|
|
|
|
|
|
no_cost_pairs = [] |
|
|
for edge in G.edges.data(): |
|
|
src, dst = edge[0], edge[1] |
|
|
if edge[-1]["cost"] is None: |
|
|
no_cost_pairs.append((src, dst)) |
|
|
print("Unable to get costs for: ", no_cost_pairs) |
|
|
|
|
|
return G |
|
|
|
|
|
|
|
|
def push_flow_helper(src, g, ingress_limit=10 * 5, egress_limit=10 * 5): |
|
|
""" |
|
|
Push positive flows in the constructed paths (g) under constraints |
|
|
TODO: fix this |
|
|
""" |
|
|
for child in list(g.successors(src)): |
|
|
dfs_edges = [edge for edge in nx.dfs_edges(g, source=child)] |
|
|
dfs_min = float("inf") if not dfs_edges else min([g[t[0]][t[1]]["throughput"] for t in dfs_edges]) |
|
|
min_flow = min([dfs_min, g[src][child]["throughput"], ingress_limit, egress_limit]) |
|
|
|
|
|
|
|
|
g[src][child]["flow"] = min_flow |
|
|
for t in dfs_edges: |
|
|
g[t[0]][t[1]]["flow"] = min_flow |
|
|
return g |
|
|
|
|
|
|
|
|
def append_src_dst_paths(src, dsts, G, bc_topology): |
|
|
|
|
|
for dst in dsts: |
|
|
for path in list(nx.all_simple_paths(G, src, dst)): |
|
|
for i in range(0, len(path) - 1): |
|
|
s, t = path[i], path[i + 1] |
|
|
for j in range(bc_topology.num_partitions): |
|
|
bc_topology.append_dst_partition_path(dst, j, [s, t, G[s][t]]) |
|
|
return bc_topology |
|
|
|
|
|
|
|
|
def networkx_to_graphviz(g, src, dsts, label="partitions"): |
|
|
"""Convert `networkx` graph `g` to `graphviz.Digraph`. |
|
|
|
|
|
@type g: `networkx.Graph` or `networkx.DiGraph` |
|
|
@rtype: `graphviz.Digraph` |
|
|
""" |
|
|
if g.is_directed(): |
|
|
h = gv.Digraph() |
|
|
else: |
|
|
h = gv.Graph() |
|
|
for u, d in g.nodes(data=True): |
|
|
|
|
|
if u.split(",")[0] == src: |
|
|
h.node(str(u.replace(":", " ")), fillcolor="red", style="filled") |
|
|
elif u.split(",")[0] in dsts: |
|
|
h.node(str(u.replace(":", " ")), fillcolor="green", style="filled") |
|
|
h.node(str(u.replace(":", " "))) |
|
|
for u, v, d in g.edges(data=True): |
|
|
|
|
|
h.edge(str(u.replace(":", " ")), str(v.replace(":", " ")), label=str(d[label])) |
|
|
|
|
|
return h |
|
|
|
