def generate_mirroring_port_utilization_compact_bar_plot(results_repository): width = 0.25 ind = np.arange(11) fig, ax = plt.subplots() solution_labels = SOLUTION_LABELS colors = cfg.BAR_PLOT_COLORS hatch = cfg.BAR_PLOT_TEXTURES bar_locations = [w for w in np.arange((width/2), len(solution_labels)*width, width)] # mean_utils :: solution_type -> switch_id -> util_list trial_name = "sub-trial-4" mean_utils = defaultdict(lambda: defaultdict(list)) for run_name in ["run-%d" % run_idx for run_idx in range(3)]: for solution_name in solution_labels: topo, flows, switches, solutions, link_utilization_data = read_results( results_repository, run_name, solution_name, trial_name) link_ids = [(s, d) for s, t in link_utilization_data[0].items() for d in t.keys()] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) dpid_to_id = {v: k for k, v in id_to_dpid.items()} for s, d in [(s, d) for s, d in link_ids if d == collector_switch_dpid]: link_utils_over_time = [] for time_idx, net_snapshot in enumerate(link_utilization_data): try: link_utils_over_time.append(net_snapshot[s][d]) except KeyError: print("net_snapshot at time %d did not contain link %s -> %s" % (time_idx, s, d)) source_switch_id = dpid_to_id[s] mean_utils[solution_name][source_switch_id].append( util.bytes_per_second_to_mbps(mean(link_utils_over_time[1:]))) for bar_idx, solution_name_to_switch_id in enumerate(mean_utils.items()): solution_name, switch_id_to_util_list = solution_name_to_switch_id data_tuples = sorted([(switch_id, mean(util_list)) for switch_id, util_list in switch_id_to_util_list.items()], key=lambda kvp: kvp[0]) std_dev_tuples = sorted([(switch_id, np.std(util_list)) for switch_id, util_list in switch_id_to_util_list.items()], key=lambda kvp: kvp[0]) ys = [d_i[1] for d_i in data_tuples] y_err = [s_i[1] for s_i in std_dev_tuples] ax.bar(ind+bar_locations[bar_idx], ys, width, color=colors[bar_idx], hatch=hatch[bar_idx], label=solution_labels[solution_name], align="center", ecolor="black", yerr=y_err) plt.rc('text', usetex=True) plt.rc('font', **cfg.FONT) plt.xlabel("Switch ID", **cfg.AXIS_LABELS) plt.ylabel("Switch load (Mbps)", **cfg.AXIS_LABELS) plt.xticks(ind+(width*len(solution_labels))/2, (ind+1)) plt.grid() plt.xlim(0, max(ind) + (width*len(solution_labels))) # plt.legend(ncol=len(solution_labels), **cfg.LEGEND) helpers.save_figure("sfm-plotthree.pdf", len(solution_labels))
def compute_theoretical_and_actual_utilization( results_repository , run_count , solution_names , trial_count): utilization_data = defaultdict(lambda: defaultdict(list)) theoretical_data = defaultdict(lambda: defaultdict(list)) for run in ["run-%d" % run_idx for run_idx in range(run_count)]: for solution_name in solution_name: for trial_name in ["sub-trial-%d" % trial_idx for trial_idx in range(trial_count)]: topo, flows, switches, solutions, net_utilization = read_results( results_repository, run, solution_name, trial_name) most_used_mirroring_port = compute_most_used_mirroring_port(flows, solutions) id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) mirror_port_dpid = id_to_dpid[most_used_mirroring_port] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() mirror_port_utils = [] for util_at_time_t in net_utilization: try: mirror_port_utils.append( util_at_time_t[mirror_port_dpid][collector_switch_dpid]) except KeyError as ke: print("KEY ERROR KE %s" % ke) theoretical_util = compute_most_used_mirroring_port_rate(switches, solutions) utilization_data[solution_name][len(flows)].extend(mirror_port_utils) theoretical_data[solution_name][len(flows)].append(theoretical_util) return utilization_data, theoretical_data
def add_flow_mirroring_flows(topology, flows, switches, solutions): flow_ids_to_add = flows.keys() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topology) flow_tokens = {} for flow_id in flow_ids_to_add: flow_tokens[flow_id] = request_flow_mirroring(flows[flow_id], switches, solutions[flow_id], id_to_dpid, flow_id) return flow_tokens
def generate_port_mirroring_port_utilization_cdf(results_repository): labels = ["rnd", "det", "df", "greedy", "optimal"] legend_labels = ["$\\epsilon$-LPR", "LPR", "DuFi", "Greedy", "Optimal"] markers = ["^", "*", "^", "o", "x"] colors = ["red", "green", "blue", "orange", "purple"] trial_name = "sub-trial-4" run_name = "run-0" for solution_idx, solution_name in enumerate(labels): topo, flows, switches, solutions, link_utilization_data, ports = read_results( results_repository, run_name, solution_name, trial_name) link_ids = [(s, d) for s, t in link_utilization_data[0].items() for d in t.keys()] mean_utils = [] labels = [] errors = [] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) dpid_to_id = {v: k for k, v in id_to_dpid.items()} for s, d in [(s, d) for s, d in link_ids if d == collector_switch_dpid]: link_utils_over_time = [] for time_idx, net_snapshot in enumerate(link_utilization_data): try: link_utils_over_time.append(net_snapshot[s][d]) except KeyError: print( "net_snapshot at time %d did not contain link %s -> %s" % (time_idx, s, d)) mean_utils.append( util.bytes_per_second_to_mbps(mean(link_utils_over_time))) errors.append( util.bytes_per_second_to_mbps(np.std(link_utils_over_time))) labels.append(dpid_to_id[s]) cdf_data = sorted(mean_utils) xs = [0.0] ys = [0.0] for idx, d in enumerate(cdf_data): xs.append(d) ys.append((1 + idx) / len(cdf_data)) plt.plot(xs, ys, label=legend_labels[solution_idx], marker=markers[solution_idx], color=colors[solution_idx]) plt.legend(loc="upper center", bbox_to_anchor=(0.5, cfg.LEGEND_HEIGHT), shadow=True, ncol=len(labels)) plt.rc('text', usetex=True) plt.rc('font', **cfg.FONT) plt.grid() plt.xlabel("Mirroring Port Rate $\\frac{Mb}{s}$") plt.ylabel("$\\mathbb{P}\\{x < \\mathcal{X}\\}$") helpers.save_figure("pm-plot-three-cdf.pdf")
def generate_mirroring_port_utilization_bar_plot(results_repository): topo, flows, switches, solutions, link_utilization_data = read_results(results_repository, "approx", "sub-trial-4") link_ids = [(s, d) for s, t in link_utilization_data[0].items() for d in t.keys()] mean_utils = [] labels = [] errors = [] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) dpid_to_id = {v: k for k, v in id_to_dpid.items()} for s, d in [(s, d) for s, d in link_ids if d == collector_switch_dpid]: link_utils_over_time = [] for time_idx, net_snapshot in enumerate(link_utilization_data): try: link_utils_over_time.append(net_snapshot[s][d]) except KeyError: print("net_snapshot at time %d did not contain link %s -> %s" % (time_idx, s, d)) mean_utils.append(util.bytes_per_second_to_mbps(mean(link_utils_over_time))) errors.append(util.bytes_per_second_to_mbps(np.std(link_utils_over_time))) labels.append(dpid_to_id[s]) ind = np.arange(1, 12) width = 0.35 fig, ax = plt.subplots() ys = [mu for mu, l in sorted(zip(mean_utils, labels), key=lambda t: t[1])] xs = labels errors = [e for e, l in sorted(zip(errors, labels), key=lambda t: t[1])] ax.set_xticks(ind+(width/2)) ax.set_xticklabels(range(1, 12)) ax.bar(ind-(width/2), ys, width, label="Measured", color="skyblue", hatch=".", yerr=errors, ecolor="black") mirroring_utils = defaultdict(float) for flow in flows.values(): mirroring_switch_for_flow = solutions[flow.flow_id].mirror_switch_id mirroring_utils[mirroring_switch_for_flow] += flow.traffic_rate ys = [] xs = [] for switch_id in range(1, 12): aggregate_rate = mirroring_utils[switch_id] xs.append(switch_id) ys.append(aggregate_rate * 100) ax.bar(ind+(width/2), ys, width, color="green", hatch="\\", label="Expected") plt.legend(loc="upper center", bbox_to_anchor=(0.5, cfg.LEGEND_HEIGHT), shadow=True, ncol=2) plt.rc('text', usetex=True) plt.rc('font', **cfg.FONT) plt.xlabel("Switch ID") plt.ylabel("Mean Mirroring Port Rate ($\\frac{Mb}{s}$)") helpers.save_figure("plot-three.pdf") plt.clf()
def add_port_mirroring_flows(topology, flows, switches, solutions, mirroring_ports): flow_ids_to_add = flows.keys() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topology) port_ids_to_port_numbers = map_port_ids_to_nw_ports(mirroring_ports, id_to_dpid) flow_tokens = {} verify_that_all_flows_are_mirrored(flows, switches, solutions, port_ids_to_port_numbers, id_to_dpid) for flow_id in flow_ids_to_add: flow_tokens[flow_id] = request_port_mirroring(flows[flow_id], switches, solutions, id_to_dpid, flow_id, port_ids_to_port_numbers) return flow_tokens
def map_to_physical_network(trial): id_to_dpid = topo_mapper.get_and_validate_onos_topo(trial.topology) port_ids_to_port_numbers = onos_rest_helpers.map_port_ids_to_nw_ports( trial.mirroring_ports, id_to_dpid) new_flows = {} for flow_id, flow in trial.flows.items(): new_path = [id_to_dpid[node] for node in flow.path] new_ports = [ port_ids_to_port_numbers[switch_id][port] for switch_id, port in zip(flow.path[:-1], flow.ports[:-1]) ] zipped_path = list(zip(new_path, new_ports)) last_hop_switch_dpid = id_to_dpid[flow.path[-1]] last_hop_egress_port = topo_mapper.get_host_port( last_hop_switch_dpid) zipped_path.append((last_hop_switch_dpid, last_hop_egress_port)) new_flow = PortMirroringFlow(flow_id, flow.traffic_rate, zipped_path) new_flows[flow_id] = new_flow new_solutions = defaultdict(list) for switch_id, solution_list in trial.solutions.items(): for solution in solution_list: new_mirror_switch_id = id_to_dpid[solution.mirror_switch_id] new_mirror_switch_port = port_ids_to_port_numbers[ solution.mirror_switch_id][solution.mirror_switch_port] new_solution = PortMirroringSolution(new_mirror_switch_id, new_mirror_switch_port, solution.objective_value) new_solutions[switch_id].append(new_solution) solutions = {} solutions[trial.solution_type] = new_solutions det_solutions = solutions.get("det", None) df_solutions = solutions.get("df", None) greedy_solutions = solutions.get("greedy", None) optimal_solutions = solutions.get("optimal", None) rnd_solutions = solutions.get("rnd", None) new_trial = PortMirroringTrial(trial.topology, new_flows, trial.switches, det_solutions, df_solutions, greedy_solutions, optimal_solutions, rnd_solutions, trial.duration, trial.name, trial.mirroring_ports) print("solution_type %s" % trial.solution_type) pp.pprint(solutions) new_trial.set_solution_type(trial.solution_type) return new_trial
def compute_theoretical_and_actual_utilization_by_run(results_repository): utilization_data = {} theoretical_data = {} for run in ["run-%d" % run_idx for run_idx in range(3)]: solution_results = {} theoretical_solution_results = {} for solution_name in ["rnd", "det", "df", "greedy", "optimal"]: trial_results = {} theoretical_trial_results = {} for trial_name in [ "sub-trial-%d" % trial_idx for trial_idx in range(5) ]: topo, flows, switches, solutions, net_utilization, ports = read_results( results_repository, run, solution_name, trial_name) most_used_mirroring_port = compute_most_used_mirroring_port( switches, solutions) id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) mirror_port_dpid = id_to_dpid[most_used_mirroring_port] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() mirror_port_utils = [] for util_at_time_t in net_utilization: try: mirror_port_utils.append( util_at_time_t[mirror_port_dpid] [collector_switch_dpid]) except KeyError as ke: print("KEY ERROR KE %s" % ke) theoretical_util = compute_most_used_mirroring_port_rate( switches, solutions) trial_results[len(flows)] = mirror_port_utils theoretical_trial_results[len(flows)] = theoretical_util solution_results[solution_name] = trial_results theoretical_solution_results[ solution_name] = theoretical_trial_results utilization_data[run] = solution_results theoretical_data[run] = theoretical_solution_results return utilization_data, theoretical_data
def compute_theoretical_and_actual_error(results_repository): utilization_data = defaultdict(list) for provider_name in ["optimal", "approx"]: for trial_idx in range(5): trial_name = "sub-trial-%d" % trial_idx topo, flows, switches, solutions, net_utilization = read_results(results_repository, provider_name, trial_name) most_used_mirroring_port = compute_most_used_mirroring_port(flows, solutions) id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) mirror_port_dpid = id_to_dpid[most_used_mirroring_port] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() utilization = [util_at_time_t[mirror_port_dpid][collector_switch_dpid] for util_at_time_t in net_utilization] utilization_data[provider_name].append((len(flows), utilization)) return utilization_data
def generate_mirroring_port_utilization_box_plot(results_repository): width = 0.25 ind = np.arange(11) fig, ax = plt.subplots() solution_labels = SOLUTION_LABELS colors = cfg.BAR_PLOT_COLORS hatch = cfg.BAR_PLOT_TEXTURES bar_locations = [w for w in np.arange((width/2), len(solution_labels)*width, width)] # mean_util_lists :: solution_type -> switch_id -> util_list trial_name = "sub-trial-4" mean_util_lists = defaultdict(lambda: defaultdict(list)) for run_name in ["run-%d" % run_idx for run_idx in range(3)]: for solution_name in solution_labels: topo, flows, switches, solutions, link_utilization_data = read_results( results_repository, run_name, solution_name, trial_name) link_ids = [(s, d) for s, t in link_utilization_data[0].items() for d in t.keys()] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) dpid_to_id = {v: k for k, v in id_to_dpid.items()} for s, d in [(s, d) for s, d in link_ids if d == collector_switch_dpid]: link_utils_over_time = [] for time_idx, net_snapshot in enumerate(link_utilization_data): try: link_utils_over_time.append(net_snapshot[s][d]) except KeyError: print("net_snapshot at time %d did not contain link %s -> %s" % (time_idx, s, d)) source_switch_id = dpid_to_id[s] most_used_id = compute_most_used_mirroring_port(flows, solutions) mean_link_utilization_for_run = util.bytes_per_second_to_mbps(mean( link_utils_over_time[1:])) if source_switch_id == most_used_id: print(solution_name, mean_link_utilization_for_run) mean_util_lists[solution_name][source_switch_id].append( mean_link_utilization_for_run) pp.pprint(mean_util_lists) mean_utils = defaultdict(dict) box_plot_lists = {} for solution_type, switch_id_to_util_list in mean_util_lists.items(): list_for_solution_type = [] for switch_id, util_list in switch_id_to_util_list.items(): # pp.pprint(util_list) mean_value = mean(util_list) list_for_solution_type.append(mean_value) mean_utils[solution_type][switch_id] = mean_value box_plot_lists[solution_type] = list_for_solution_type box = plt.boxplot([box_plot_lists[solution_name] for solution_name in SOLUTION_NAMES], labels=[solution_labels[solution_name] for solution_name in SOLUTION_NAMES], patch_artist=True, widths=[0.5]*len(SOLUTION_NAMES)) for element in ["boxes", "whiskers", "fliers", "means", "medians", "caps"]: plt.setp(box[element], color="black") for idx, patch in enumerate(box["boxes"]): patch.set(facecolor=cfg.BAR_PLOT_COLORS[idx], hatch=cfg.BAR_PLOT_TEXTURES[idx]) plt.rc('text', usetex=True) plt.rc('font', **cfg.FONT) plt.xlabel("Algorithm", **cfg.AXIS_LABELS) plt.ylabel("Switch load (Mbps)", **cfg.AXIS_LABELS) plt.grid(**cfg.GRID) helpers.save_figure("sfm-boxplot.pdf")
def generate_mirroring_port_utilization_bar_plot(results_repository): labels = ["rnd", "det", "df", "greedy", "optimal"] legend_labels = ["\\epsilon-LPR", "LPR", "DuFi", "Greedy", "Optimal"] trial_name = "sub-trial-4" run_name = "run-0" for solution_name in labels: topo, flows, switches, solutions, link_utilization_data, ports = read_results( results_repository, run_name, solution_name, trial_name) link_ids = [(s, d) for s, t in link_utilization_data[0].items() for d in t.keys()] mean_utils = [] labels = [] errors = [] collector_switch_dpid = topo_mapper.get_collector_switch_dpid() id_to_dpid = topo_mapper.get_and_validate_onos_topo(topo) dpid_to_id = {v: k for k, v in id_to_dpid.items()} for s, d in [(s, d) for s, d in link_ids if d == collector_switch_dpid]: link_utils_over_time = [] for time_idx, net_snapshot in enumerate(link_utilization_data): try: link_utils_over_time.append(net_snapshot[s][d]) except KeyError: print( "net_snapshot at time %d did not contain link %s -> %s" % (time_idx, s, d)) mean_utils.append( util.bytes_per_second_to_mbps(mean(link_utils_over_time))) errors.append( util.bytes_per_second_to_mbps(np.std(link_utils_over_time))) labels.append(dpid_to_id[s]) ind = np.arange(1, 12) width = 0.35 fig, ax = plt.subplots() ys = [ mu for mu, l in sorted(zip(mean_utils, labels), key=lambda t: t[1]) ] xs = labels errors = [ e for e, l in sorted(zip(errors, labels), key=lambda t: t[1]) ] ax.set_xticks(ind + (width / 2)) ax.set_xticklabels(range(1, 12)) ax.bar(ind - (width / 2), ys, width, label="Measured", color="skyblue", hatch=".", yerr=errors, ecolor="black") mirroring_utils = compute_theoretical_mirroring_rates_for_switches( switches, solutions) ys = [] xs = [] for switch_id in switches.keys(): aggregate_rate = mirroring_utils[switch_id] xs.append(switch_id) ys.append(aggregate_rate * pm_cfg.rate_factor) ax.bar(ind + (width / 2), ys, width, color="green", hatch="\\", label="Expected") plt.legend(loc="upper center", bbox_to_anchor=(0.5, cfg.LEGEND_HEIGHT), shadow=True, ncol=2) plt.rc('text', usetex=True) plt.rc('font', **cfg.FONT) plt.xlabel("Switch ID") plt.ylabel("Mean Mirroring Port Rate ($\\frac{Mb}{s}$)") plt.grid() helpers.save_figure("plot-three-%s.pdf" % solution_name) plt.clf()