def generate_goodput_vs_message_size_scatter():
results_file = MININET_RESULTS_DIR / "results_msgsize" / "results.log"
results_dicts = [
eval(s_i) for s_i in results_file.read_text().splitlines()
]
host_hopping_trials = [
d_i for d_i in results_dicts
if d_i["experiment"]["hop_method"] == "host"
]
net_hopping_trials = [
d_i for d_i in results_dicts
if d_i["experiment"]["hop_method"] == "net"
]
msg_size_selector = lambda d_i: d_i["experiment"]["msg_size"]
scatter_points = compute_mean_goodput(host_hopping_trials,
msg_size_selector)
xs = [t_i[0] for t_i in scatter_points]
ys = [t_i[1] for t_i in scatter_points]
helpers.plot_a_scatter(xs,
ys,
idx=0,
label=helpers.legend_font("Host hopping"))
scatter_points = compute_mean_goodput(net_hopping_trials,
msg_size_selector)
xs = [t_i[0] for t_i in scatter_points]
ys = [t_i[1] for t_i in scatter_points]
helpers.plot_a_scatter(xs,
ys,
idx=1,
label=helpers.legend_font("Net hopping"))
plt.xlabel(helpers.axis_label_font("Message size (Bytes)"))
plt.ylabel(helpers.axis_label_font("Mbps"))
helpers.save_figure("msg_goodput.pdf", num_cols=2)
def generate_number_of_time_periods_shares_were_active_pdf(set_of_traces_to_plot, trace_names):
"""
Generate a plot of the probability density function of the number of \delta ms time
periods that shares for a particular sequence number were present in the network. A single
PDF is generated and plotted for each ofthe traces in <set_of_traces_to_plot>.
"""
bar_width = 0.35
possible_x_values = set()
for bar_idx, (trace_name, packets) in enumerate(zip(trace_names, set_of_traces_to_plot)):
packets = sorted(packets, key=lambda p_i: p_i.timestamp)
delta = 100 * 10**3
interval_start = packets[0].timestamp
current_time = packets[0].timestamp
seq_num_to_list_of_intervals = defaultdict(list)
interval_index = 0
for p_i in packets:
current_time = p_i.timestamp
if (current_time - interval_start) > delta:
interval_index += 1
interval_start = current_time
seq_num_to_list_of_intervals[p_i.seq_num].append(interval_index)
seq_num_to_interval_count = {}
for seq_num, list_of_intervals in seq_num_to_list_of_intervals.items():
seq_num_to_interval_count[seq_num] = (max(list_of_intervals) - \
min(list_of_intervals)) + 1
counted_data = list(Counter(seq_num_to_interval_count.values()).items())
hist_data_for_trace = sorted(counted_data,
key=lambda kvp_i: kvp_i[0])
possible_x_values = possible_x_values | set([t_i[0] for t_i in hist_data_for_trace])
vector_sum = sum((t_i[1] for t_i in hist_data_for_trace))
normed_hist_data_for_trace = [t_i[1] / vector_sum for t_i in hist_data_for_trace]
bar_x_locations = [t_i[0] + (bar_width * bar_idx) for t_i in hist_data_for_trace]
helpers.plot_a_bar(bar_x_locations, normed_hist_data_for_trace,
idx=bar_idx, bar_width=bar_width, label=helpers.legend_font(trace_name))
x_tick_labels = list(sorted(possible_x_values))
x_tick_locations = [x_i + ((bar_width/2) * (len(set_of_traces_to_plot)-1))
for x_i in x_tick_labels]
plt.xticks(x_tick_locations, x_tick_labels)
# plt.xlabel(r"Number of $\delta$ms intervals sequence shares were present in the network")
plt.ylabel(helpers.axis_label_font(r"$\mathbb{P}\{x = \mathcal{X}\}$"))
helpers.save_figure("share-presence-pdf.pdf", num_cols=len(set_of_traces_to_plot))
def generate_attacker_vs_k_scatter():
def attacker_setting(trial_dict):
return trial_dict["experiment"]["attacker_setting"]
def attacker_timestep(trial_dict):
return trial_dict["experiment"]["attacker_timestep"]
results_file = MININET_RESULTS_DIR / "results_attacker_k" / "results.log"
results_dicts = [
eval(s_i) for s_i in results_file.read_text().splitlines()
]
# pp.pprint(results_dicts)
print(len(results_dicts))
# pp.pprint([attacker_timestep(d_i) for d_i in results_dicts])
fixed_attacker_trials = [
d_i for d_i in results_dicts if attacker_setting(d_i) == "fixed"
]
unsynced_attacker_trials = [
d_i for d_i in results_dicts
if attacker_setting(d_i) == "hop_independent"
]
synced_attacker_trials = [
d_i for d_i in results_dicts if attacker_setting(d_i) == "hop_sync"
]
trial_data_list = [
fixed_attacker_trials, unsynced_attacker_trials, synced_attacker_trials
]
trial_names = ["Fixed", "Independent", "Synced"]
k_selector = lambda d_i: d_i["experiment"]["k"]
for plot_idx, (trial_name,
trial_data) in enumerate(zip(trial_names, trial_data_list)):
scatter_points = compute_mean_data_recovery(trial_data, k_selector)
# pp.pprint(scatter_points)
xs = [t_i[0] for t_i in scatter_points]
ys = [t_i[1] / 1000 for t_i in scatter_points] # to KB
helpers.plot_a_scatter(xs,
ys,
idx=plot_idx,
label=helpers.legend_font(trial_name))
plt.xlabel(helpers.axis_label_font("$K$"))
plt.ylabel(helpers.axis_label_font("Kilobytes"))
helpers.save_figure("attacker.pdf", num_cols=len(trial_data_list))
def generate_active_paths_per_interval_plot(set_of_traces_to_plot, trace_names):
"""
Generate a plot of the probability density function of the number of active paths
per \delta ms interval. A path is defined as being active if it is carrying
shares for any sequence number.
"""
bar_width = 0.4
possible_x_values = set()
for bar_idx, (trace_name, packets) in enumerate(zip(trace_names, set_of_traces_to_plot)):
packets = sorted(packets, key=lambda p_i: p_i.timestamp)
delta = 100 * 10**3 # microseconds
interval_start = packets[0].timestamp
current_time = packets[0].timestamp
active_ports_in_interval = set()
number_of_active_paths_per_interval = []
for p_i in packets:
current_time = p_i.timestamp
if (current_time - interval_start) > delta:
number_of_active_paths_per_interval.append(len(active_ports_in_interval))
active_ports_in_interval = set()
interval_start = current_time
active_ports_in_interval.add((p_i.source_port, p_i.destination_port))
counted_data = list(Counter(number_of_active_paths_per_interval).items())
hist_data_for_trace = sorted(counted_data,
key=lambda kvp_i: kvp_i[0])
possible_x_values = possible_x_values | set([t_i[0] for t_i in hist_data_for_trace])
vector_sum = sum([t_i[1] for t_i in hist_data_for_trace])
normed_hist_data_for_trace = [t_i[1] / vector_sum for t_i in hist_data_for_trace]
bar_x_locations = [t_i[0] + (bar_width * bar_idx) for t_i in hist_data_for_trace]
helpers.plot_a_bar(bar_x_locations, normed_hist_data_for_trace,
idx=bar_idx, bar_width=bar_width, label=helpers.legend_font(trace_name))
# x_tick_labels = list(sorted(possible_x_values))
x_tick_labels = np.arange(min(possible_x_values), max(possible_x_values) + 1)
x_tick_locations = [x_i + ((bar_width/2) * (len(set_of_traces_to_plot)-1)) for x_i in
x_tick_labels]
plt.xticks(x_tick_locations, x_tick_labels)
plt.ylabel(helpers.axis_label_font(r"$\mathbb{P}\{x = \mathcal{X}\}$"))
helpers.save_figure("active-paths-histogram.pdf", num_cols=len(set_of_traces_to_plot))
def generate_computed_link_utilization_cdf(trial_provider):
grouped_by_name = collect_trials_based_on_name(trial_provider)
labels = [multiflow_label(group[0].name) for group in grouped_by_name]
link_utilizations = [reduce(op.add,
[list(t_i.get_parameter("measured-link-utilization").values())
for t_i in group if t_i.has_parameter("measured-link-utilization")], [])
for group in grouped_by_name]
for plot_idx in range(len(labels)):
sorted_link_utilization_data = sorted(link_utilizations[plot_idx])
plot_a_cdf(sorted_link_utilization_data, idx=plot_idx,
label=helpers.legend_font(labels[plot_idx]))
plt.xlabel(helpers.axis_label_font("Link Utilization"))
plt.ylabel(helpers.axis_label_font(r"$\mathbb{P}\{x \leq \mathcal{X}\}$"))
node_selection_type = trial_provider.get_metadata("node-selection-type")
legend_kwargs = dict(cfg.LEGEND)
helpers.save_figure("computed-link-utilization-%s-cdf.pdf" % node_selection_type,
num_cols=len(trial_provider), legend_kwargs=legend_kwargs)
def plot_share_delay_cdf_across_ks(plot_name, packet_info_dir):
"""
Generate share delay cumulative distribution function plots for a fixed set of K values.
"""
k_to_packets = {}
for k_value in range(3, 9):
packets_file_path = packet_info_dir.joinpath(path.Path("packet-dump-info-%d.txt" % k_value))
k_to_packets[k_value] = read_packet_dump_info_from_file(packets_file_path)
for plot_idx, (k_value, packets) in enumerate(k_to_packets.items()):
plot_share_delay_cdf(packets, label=helpers.legend_font(r"$K$=%d" % k_value),
idx=plot_idx)
title_string = r"$n=10$, $\lambda=50$, $\delta=100ms$, $latency=\mathcal{U}(0ms, 250ms)$, $jitter=50ms$"
# plt.title(title_string)
plt.xlabel(helpers.axis_label_font(r"Inter-share delay ($ms$)"))
plt.ylabel(helpers.axis_label_font(r"$\mathbb{P}\{x < \mathcal{X}\}$"))
legend_kwargs = dict(cfg.LEGEND)
legend_kwargs["loc"] = "upper center"
legend_kwargs["bbox_to_anchor"] = (0.5, 1.2)
helpers.save_figure("inter-share-latency-%s-cdf.pdf" % plot_name,
num_cols=(len(k_to_packets)//2), legend_kwargs=legend_kwargs)
def generate_loss_vs_timestep_plot():
host_hopping = [(100, 0.0), (250, 0.0), (500, 0.0), (1000, 0.0),
(5000, 0.0), (10000, 0.0)]
net_hopping = [(100, 0.32), (250, 0.14), (500, 0.093), (1000, 0.025),
(5000, 0.015), (10000, 0.0)]
trial_names = ["Host hopping", "Net hopping"]
trial_data_lists = [host_hopping, net_hopping]
for plot_idx, (trial_name,
trial_data) in enumerate(zip(trial_names,
trial_data_lists)):
xs = [t_i[0] for t_i in trial_data]
ys = [t_i[1] for t_i in trial_data]
helpers.plot_a_scatter(xs,
ys,
idx=plot_idx,
label=helpers.legend_font(trial_name))
plt.xlim((0.0, 10000))
plt.ylim((0.0, 0.35))
plt.xlabel(helpers.axis_label_font("Timestep (ms)"))
plt.ylabel(helpers.axis_label_font("Packet loss rate"))
helpers.save_figure("loss-plot.pdf", num_cols=2)
def plot_best_and_worst_paths_cdf(capture_name, packets, **kwargs):
"""
Generate a plot showing the cumulative distribution function of the inter-share delay
for the 5 best and 5 worst K-sized sets of paths in the network. In this context
The terms best and worst refer to the K-sized sets of paths with the smallest and
largest inter-share delay respectively.
"""
def configure_plot(figure):
pass
# want to group by the sequence number and the set of ports
key_fn = lambda p_i: p_i.seq_num
packets = sorted(packets, key=key_fn)
groups = itertools.groupby(packets, key_fn)
port_group_to_isd = defaultdict(list)
for seq_num, packets_with_seq_num in groups:
packet_group = list(packets_with_seq_num)
port_key = tuple(sorted([p_i.destination_port for p_i in packet_group]))
ts_selector = lambda p_i: p_i.timestamp
inter_share_delay = ts_selector(max(packet_group, key=ts_selector)) - \
ts_selector(min(packet_group, key=ts_selector))
port_group_to_isd[port_key].append(inter_share_delay / 1000)
def compute_95th_percentile(data):
data = sorted(data)
idx = int(np.floor(0.95 * len(data)))
return data[idx]
fig, axs = plt.subplots(2, sharex=True)
best_paths_axis = axs[0]
worst_paths_axis = axs[1]
large_bold = lambda phrase: helpers.LARGE(helpers.bf(phrase))
best_paths_axis.text(0, 0.90, large_bold("Best paths"))
worst_paths_axis.text(0, 0.90, large_bold("Worst paths"))
sorted_paths = sorted([(port_key, inter_share_delays)
for port_key, inter_share_delays in port_group_to_isd.items()],
key=lambda t_i: np.mean(t_i[1]))
best_paths = sorted_paths[:5]
worst_paths = sorted_paths[len(sorted_paths)-5:]
for plot_idx, (port_group, inter_share_delays) in enumerate(best_paths):
helpers.plot_a_cdf(sorted(inter_share_delays), idx=plot_idx, plot_markers=False,
axis_to_plot_on=best_paths_axis, label_data=False)
percentile_label = helpers.legend_font(r"$95$th-Percentile")
all_latencies = list(itertools.chain(*[b_i[1] for b_i in best_paths]))
percentile_95 = compute_95th_percentile(all_latencies)
best_paths_axis.axvline(percentile_95, color="red", linestyle="--",
label=percentile_label)
legend_params = dict(cfg.LEGEND)
legend_params["loc"] = "upper center"
legend_params["bbox_to_anchor"] = (0.5, 1.3)
best_paths_axis.legend(ncol=1, **legend_params)
for plot_idx, (port_group, inter_share_delays) in enumerate(worst_paths):
helpers.plot_a_cdf(sorted(inter_share_delays), idx=plot_idx, plot_markers=False,
axis_to_plot_on=worst_paths_axis, label_data=False)
all_latencies = list(itertools.chain(*[w_i[1] for w_i in worst_paths]))
percentile_95 = compute_95th_percentile(all_latencies)
worst_paths_axis.axvline(percentile_95, color="red", linestyle="--",
label=percentile_label)
y_label_str = helpers.axis_label_font(r"$\mathbb{P}\{x < \mathcal{X}\}$")
worst_paths_axis.set_xlabel(helpers.axis_label_font(r"Inter-Share Delay ($ms$)"))
worst_paths_axis.set_ylabel(y_label_str)
best_paths_axis.set_ylabel(y_label_str)
configure_plot(fig)
axis_to_plot = [best_paths_axis, worst_paths_axis]
helpers.save_subfigure_plot("best-and-worst-paths-%s-cdf.pdf" % capture_name,
axis_to_plot, no_legend=True)