| | 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 |
| |
|
