def generate_loss_rate_cdf(results_repository):
trial_name = "test-trial-830656277"
seed_numbers = [trial_name]
for idx, trial_type in enumerate(TRIAL_TYPES):
loss_rates_for_seed_number = []
for seed_number in seed_numbers:
loss_rate_per_flow = generate_loss_rates(results_repository,
trial_type, seed_number)
xs = [0.0]
ys = [0.0]
for ctr, loss_rate in enumerate(sorted(loss_rate_per_flow)):
xs.append(loss_rate)
ys.append((ctr + 1) / len(loss_rate_per_flow))
plt.plot(xs,
ys,
linestyle="-",
marker=helpers.marker_style(idx),
label=LABEL_NAMES[idx],
color=helpers.line_color(idx))
plt.rc("font", **cfg.FONT)
plt.rc("legend", edgecolor="black")
# xtick_locations = [200, 400, 600, 800, 1000]
plt.xlim(0.0)
plt.ylim(0.0, 1.0)
xtick_locations, xtick_labels = plt.xticks()
ytick_locations, ytick_labels = plt.yticks()
plt.xticks(xtick_locations[1:],
[helpers.tick_font(x_i, "%.2f") for x_i in xtick_locations][1:])
plt.yticks(ytick_locations[1:],
[helpers.tick_font(y_i, "%.1f") for y_i in ytick_locations][1:])
plt.ylabel("CDF", **cfg.AXIS_LABELS)
helpers.save_figure("loss-rate-cdf.pdf", 1)
def generate_simulation_run_time_plot(results_repository):
def mean_confidence_interval(data, confidence=0.95):
a = 1.0 * np.array(data)
n = len(a)
m, se = np.mean(a), scipy.stats.sem(a)
h = se * scipy.stats.t.ppf((1 + confidence) / 2., n - 1)
# return m, m-h, m+h
return h
series_data = {}
for flow_count in [100, 500, 1000]:
data_for_node_counts = []
for node_count in [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]:
data_for_single_count = []
seed_numbers = [
742349042, 2787879137, 3102739139, 2303690384, 1672982999,
2501915964, 2853959085, 3163893110, 462786850, 4124106680
]
for seed_number in seed_numbers:
sim = read_results(results_repository, flow_count, node_count,
seed_number)
data_for_single_count.append(sim.solution_time)
pp.pprint(data_for_single_count)
ci = mean_confidence_interval(data_for_single_count)
data_for_node_counts.append(
(node_count, np.mean(data_for_single_count), ci))
series_data[flow_count] = data_for_node_counts
for idx, (flow_count, data_for_node_counts) in enumerate(
sorted(series_data.items(), key=lambda t: t[0])):
xs = [d_i[0] for d_i in data_for_node_counts]
ys = [d_i[1] for d_i in data_for_node_counts]
std_dev = [d_i[2] for d_i in data_for_node_counts]
plt.errorbar(xs,
ys,
label="\\LARGE{%d VLs}" % flow_count,
marker=cfg.MARKER_STYLE[idx],
linestyle=helpers.line_style(idx),
color=helpers.line_color(idx),
yerr=std_dev,
capsize=2)
plt.rc("text", usetex=True)
matplotlib.rcParams['text.latex.preamble'] = [
r'\usepackage{amsmath}', r'\usepackage{amssymb}'
]
plt.rc("font", **cfg.FONT)
plt.rc("legend", edgecolor="black")
xtick_locations = [200, 400, 600, 800, 1000]
ytick_locations = [2, 4, 6, 8, 10, 12, 14]
plt.xticks(xtick_locations,
[helpers.tick_font(x_i) for x_i in xtick_locations])
plt.yticks(ytick_locations,
[helpers.tick_font(y_i) for y_i in ytick_locations])
plt.xlabel("Number of Nodes", **cfg.AXIS_LABELS)
plt.ylabel("Running Time (s)", **cfg.AXIS_LABELS)
helpers.save_figure("sim-running-time.pdf", 1)
def generate_heterogeneous_links_instantaneous_rate_plot():
link_rate_count = 100
labels = {
(100, 0): "\\LARGE{$\\mu=100$, $\\text{CoV}=0.0$}",
(100, 50): "\\LARGE{$\\mu=100$, $\\text{CoV}=0.5$}",
(100, 100): "\\LARGE{$\\mu=100$, $\\text{CoV}=1.0$}"
}
colors = {(100, 0): "red", (100, 50): "lime", (100, 100): "blue"}
plt.plot(range(link_rate_count), [100 for _ in range(link_rate_count)],
label=labels[100, 0],
color=colors[100, 0])
for mu, sigma in [(100, 50), (100, 100)]:
link_rates = heterogeneous_links.get_heterogeneous_link_rates(
mu, sigma**2, link_rate_count)
xs = range(len(link_rates))
ys = link_rates
plt.plot(xs, ys, label=labels[mu, sigma], color=colors[mu, sigma])
plt.rc('font', **cfg.FONT)
plt.xlim(0, link_rate_count - 1)
plt.xlabel("Time", **cfg.AXIS_LABELS)
plt.ylabel("Transmission Rate (Mbps)", **cfg.AXIS_LABELS)
xtick_locations, xtick_labels = plt.xticks()
ytick_locations, ytick_lables = plt.yticks()
plt.ylim(0, ytick_locations[-1])
plt.xticks(xtick_locations[1:], ["" for x_i in xtick_locations])
plt.yticks(ytick_locations[1:],
[helpers.tick_font(y_i, "%.0f") for y_i in ytick_locations][1:])
helpers.save_figure("actual-model-tx-rates.pdf", 1, no_legend=False)
def generate_traffic_on_path_bar_plot(data_file):
def read_literal_from_file(data_file):
with data_file.open("r") as fd:
python_literal = eval(fd.read())
return python_literal
path_data = read_literal_from_file(data_file)
xs = []
ys = []
target_path_ratios = [0.5, 0.3, 0.2]
cs = []
bar_width = 0.2
pos = 0.1
for path_idx, (k, v) in enumerate(
sorted(path_data.items(), key=lambda t: t[1], reverse=True)):
y_val = v / sum(path_data.values())
cs.append("blue")
cs.append("green")
plt.bar(pos - 0.01, y_val, bar_width, color="gray", edgecolor="black")
pos += bar_width
plt.bar(pos + 0.01,
target_path_ratios[path_idx],
bar_width,
color="blue",
edgecolor="black")
pos += bar_width
pos += 0.1
print("VALUE: %f" % (abs(y_val - target_path_ratios[path_idx]) /
target_path_ratios[path_idx]))
# labels=["Path %d" % path_idx for path_idx in range(1, 4)]
# plt.bar(xs, ys, edgecolor="black", color=cs)
legend_labels = [
"\\Large{expected data volume}", "\\Large{actual data volume}"
]
legend_colors = ["blue", "gray"]
patches = [
matplotlib.patches.Patch(color=c, label=l, edgecolor="black")
for c, l in zip(legend_colors, legend_labels)
]
plt.legend(handles=patches, ncol=2, **cfg.LEGEND)
xtick_labels = ["Path %d" % path_id for path_id in range(1, 4)]
xtick_locations = [l_i for l_i in np.arange(0.2, 1.5, 0.5)]
plt.xticks(xtick_locations, xtick_labels)
ytick_locations, ytick_labels = plt.yticks()
plt.yticks(ytick_locations,
[helpers.tick_font(y_i, "%.1f") for y_i in ytick_locations])
plt.ylabel("Normalized Data Volume", **cfg.AXIS_LABELS)
helpers.save_figure("per-path-data-volume.pdf", no_legend=True)
def generate_link_utilization_box_plot(results_repository):
list_of_mean_utils = []
for trial_type in TRIAL_TYPES:
mean_link_utils_per_seed_number = []
for idx, seed_number in enumerate(["test-trial-830656277"]):
utilization_results, the_vle_trial, end_host_results = read_results(
results_repository, trial_type, seed_number)
link_utilization_data = compute_network_util_over_time(
utilization_results)
link_ids = [(s, d) for s, t in link_utilization_data[0].items()
for d in t.keys()]
mean_utils = {}
for s, d in link_ids:
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[s, d] = ((mean(link_utils_over_time) * 8) / 10**6 /
1000)
list_of_mean_utils.append(mean_utils)
pp.pprint([list(v.values()) for v in list_of_mean_utils])
bp = plt.boxplot([list(v.values()) for v in list_of_mean_utils],
labels=LABEL_NAMES,
whiskerprops={"linestyle": "--"},
flierprops={
"marker": "x",
"markerfacecolor": "red",
"markeredgecolor": "red"
})
for element in ["boxes"]:
plt.setp(bp[element], color="blue")
plt.setp(bp["medians"], color="red")
plt.rc("font", **cfg.FONT)
plt.rc("legend", edgecolor="black")
# xtick_locations = [200, 400, 600, 800, 1000]
# ytick_locations = [2, 4, 6, 8, 10, 12, 14]
ytick_locations, _ = plt.yticks()
plt.yticks(ytick_locations,
[helpers.tick_font(y_i, "%.1f") for y_i in ytick_locations])
plt.ylabel("Link Utilization", **cfg.AXIS_LABELS)
helpers.save_figure("link-utilization-box-plot.pdf", 3, no_legend=True)
def generate_throughput_over_time_plot(data_file):
def read_literal_from_file(data_file):
with data_file.open("r") as fd:
python_literal = eval(fd.read())
return python_literal
path_id_to_ratio_map = {4: 0.5, 8: 0.3, 12: 0.2}
path_to_tputs = read_literal_from_file(data_file)
num_points = 15
for plot_idx, (path_id, tputs) in enumerate(
sorted(path_to_tputs.items(), key=lambda t: t[0])):
tputs = tputs[1:num_points + 1]
xs = np.arange(num_points)
plt.plot(xs,
tputs,
linestyle="-.",
marker=marker_style(plot_idx),
color=line_color(plot_idx))
plt.plot(np.arange(len(tputs)),
[path_id_to_ratio_map[path_id] for _ in range(len(tputs))],
color=line_color(plot_idx),
linestyle="-",
linewidth=0.75)
lines = [
matplotlib.lines.Line2D([0], [0],
c="black",
linestyle=s_i,
linewidth=width)
for s_i, width in [("-", 0.75), ("-.", 1.0)]
]
legend_labels = [
"\\Large{expected throughput}", "\\Large{actual throughput}"
]
plt.legend(lines, legend_labels, ncol=1, **cfg.LEGEND)
plt.ylim(0.0, 0.6)
xtick_locations, xtick_labels = plt.xticks()
plt.xticks(xtick_locations[1:-1], ["" for _ in xtick_locations][1:-1])
ytick_locations, ytick_labels = plt.yticks()
plt.yticks(ytick_locations[1:],
[helpers.tick_font(y_i) for y_i in ytick_locations][1:])
plt.xlabel("Time", **cfg.AXIS_LABELS)
plt.ylabel("Normalized Throughput", **cfg.AXIS_LABELS)
helpers.save_figure("per-path-throughput.pdf", no_legend=True)
def generate_flow_rate_plot(results_repository):
trial_name = "test-trial-830656277"
utiliztation_results, the_vle_trial, end_host_results = read_results(
results_repository, "link-embedding", trial_name)
pp.pprint(the_vle_trial.actual_flow_tx_rates)
for flow_rates in the_vle_trial.actual_flow_tx_rates[:5]:
plt.plot(np.arange(len(flow_rates)), flow_rates)
# plt.rc('text', usetex=True)
plt.xlim(0, 59)
plt.rc('font', **cfg.FONT)
plt.xlabel("Time", **cfg.AXIS_LABELS)
plt.ylabel("Transmission Rate (Mbps)", **cfg.AXIS_LABELS)
xtick_locations, xtick_labels = plt.xticks()
ytick_locations, ytick_lables = plt.yticks()
plt.xticks(xtick_locations[1:], ["" for x_i in xtick_locations])
plt.yticks(ytick_locations[1:],
[helpers.tick_font(y_i, "%.0f") for y_i in ytick_locations][1:])
# plt.legend(ncol=2, **cfg.LEGEND)
helpers.save_figure("actual-trace-tx-rates.pdf", 2, no_legend=True)
def generate_virtual_link_count_plot(results_repository):
trial_to_virtual_link_counts = {}
for trial_type in TRIAL_TYPES:
trial_to_virtual_link_counts[trial_type] = []
for idx, seed_number in enumerate(SEED_NUMBERS):
utilization_results, the_vle_trial, end_host_results = read_results(
results_repository, trial_type, seed_number)
number_of_virtual_links = len(the_vle_trial.solver_results.flows)
trial_to_virtual_link_counts[trial_type].append(
number_of_virtual_links)
data_to_be_plotted = {}
width = 0.1
box_offset = (width / 2)
box_locations = []
for trial_idx, trial_type in enumerate(TRIAL_TYPES):
mean_virtual_link_count = np.mean(
trial_to_virtual_link_counts[trial_type])
virtual_link_count_std_dev = np.std(
trial_to_virtual_link_counts[trial_type])
box_locations.append(box_offset)
plt.bar(box_offset,
int(mean_virtual_link_count),
width,
color="blue",
edgecolor="black",
yerr=virtual_link_count_std_dev,
ecolor="red",
capsize=2)
box_offset += (width + 0.1)
xtick_locations, xtick_labels = plt.xticks()
plt.xticks(box_locations, LABEL_NAMES)
ytick_locations, ytick_labels = plt.yticks()
plt.yticks(ytick_locations,
[helpers.tick_font(int(y_i)) for y_i in ytick_locations])
plt.ylabel("No. of Admitted VLs", **cfg.AXIS_LABELS)
helpers.save_figure("virtual-link-counts.pdf", no_legend=True)
def generate_flow_means_plot():
tx_rate_list, mean_flow_tx_rates, std_dev_flow_tx_rates = core_taps.get_rates_for_flows(
)
number_of_flows_to_plot = 40
plt.errorbar([idx + 1 for idx in range(number_of_flows_to_plot)],
mean_flow_tx_rates[:number_of_flows_to_plot],
color="red",
marker="D",
yerr=std_dev_flow_tx_rates[:number_of_flows_to_plot],
linestyle="",
capsize=2)
plt.rc('font', **cfg.FONT)
plt.xlim(0, number_of_flows_to_plot)
plt.ylabel("Mean Transmission Rate (Mbps)", **cfg.AXIS_LABELS)
plt.xlabel("Virtual Links", **cfg.AXIS_LABELS)
xtick_locations, xtick_labels = plt.xticks()
ytick_locations, ytick_lables = plt.yticks()
plt.xticks(xtick_locations[1:], ["" for x_i in xtick_locations][1:])
plt.yticks(ytick_locations[1:],
[helpers.tick_font(y_i, "%.0f") for y_i in ytick_locations][1:])
helpers.save_figure("mean-trace-tx-rates.pdf", 2, no_legend=True)
def generate_heterogeneous_links_mean_rate_plot():
link_rate_count = 1000
number_of_links = 10
labels = {
(100, 0): "$\\mu=100$, $\\text{CoV}=0.0$",
(100, 50): "$\\mu=100$, $\\text{CoV}=0.5$",
(100, 100): "$\\mu=100$, $\\text{CoV}=1.0$"
}
colors = {(100, 0): "red", (100, 50): "lime", (100, 100): "blue"}
flow_stats = []
loc_idx = [idx + 1 for idx in range(number_of_links * 3)]
idx = 0
np.random.shuffle(loc_idx)
msize = 4.0
for _ in range(number_of_links):
link_rates = [100 for _ in range(link_rate_count)]
flow_stats.append((np.mean(link_rates), np.std(link_rates), colors[100,
0]))
plt.errorbar(loc_idx[idx],
np.mean(link_rates),
yerr=0,
color=colors[100, 0],
capsize=2,
linestyle="",
marker="D",
markersize=msize)
idx += 1
for mu, sigma in [(100, 50), (100, 100)]:
for _ in range(number_of_links):
link_rates = heterogeneous_links.get_heterogeneous_link_rates(
mu, sigma**2, link_rate_count)
flow_stats.append(
(np.mean(link_rates), np.std(link_rates), colors[mu, sigma]))
plt.errorbar(loc_idx[idx],
np.mean(link_rates),
yerr=np.std(link_rates),
color=colors[mu, sigma],
capsize=2,
linestyle="",
marker="D",
markersize=msize)
idx += 1
# plot_order = np.random.choice(flow_stats, size=len(flow_stats), replace=False)
# plot_order = flow_stats
# np.random.shuffle(plot_order)
# err = [p_i[1] for p_i in plot_order]
# ys = [p_i[0] for p_i in plot_order]
# color_list = [p_i[2] for p_i in plot_order]
# plt.errorbar(range(len(ys)), ys, yerr=err, linestyle="", marker="D",
# capsize=2, c=color_list)
lines = [
matplotlib.lines.Line2D([0], [0],
c=c_i,
linestyle="",
marker="D",
markersize=msize)
for c_i in [colors[100, 0], colors[100, 50], colors[100, 100]]
]
legend_labels = [
"\\LARGE{%s}" % labels[100, 0],
"\\LARGE{%s}" % labels[100, 50],
"\\LARGE{%s}" % labels[100, 100]
]
plt.legend(lines, legend_labels, ncol=1, **cfg.LEGEND)
plt.rc('font', **cfg.FONT)
plt.xlim(0, number_of_links * 3)
plt.ylabel("Mean Transmission Rate (Mbps)", **cfg.AXIS_LABELS)
plt.xlabel("Virtual Links", **cfg.AXIS_LABELS)
xtick_locations, xtick_labels = plt.xticks()
ytick_locations, ytick_lables = plt.yticks()
plt.ylim(0, ytick_locations[-1])
plt.xticks(xtick_locations[1:], ["" for x_i in xtick_locations][1:])
plt.yticks(ytick_locations[1:],
[helpers.tick_font(y_i, "%.0f") for y_i in ytick_locations][1:])
helpers.save_figure("mean-model-tx-rates.pdf", 1, no_legend=True)