RTN'18 dump (6674aef1) · Commits · LARN / X-Lap

xlap/analyse/diff.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@ def duration_to_string(d):
		return str(d['Start']) + "->" + str(d['Stop'])

		def analyse(df1, df2, config, export=False):
		for d in latency.get_durations(df1, config):
		for d in latency.get_durations_2([df1, df2], config):
		data1 = df1[d['Stop']] - df1[d['Start']]
		data2 = df2[d['Stop']] - df2[d['Start']]
		if samples_are_different(remove_outliers(data1), remove_outliers(data2)) and samples_are_different(data1, data2):

xlap/analyse/e2e.py

0 → 100644

+81 −0

Original line number	Diff line number	Diff line
		import math
		import numpy as np
		from .util import cdf, extract_durations
		from scipy import stats
		import matplotlib.pyplot as plt
		import xlap.analyse.latency as latency

		# Taken from: http://composition.al/blog/2015/11/29/a-better-way-to-add-labels-to-bar-charts-with-matplotlib/
		def autolabel(rects, ax, labels):
		# Get y-axis height to calculate label position from.
		(x_left, x_right) = ax.get_xlim()
		x_width = x_right - x_left

		for i, rect in enumerate(rects):
		width = rect.get_width()
		color = "black"
		align = "left"

		# Fraction of axis height taken up by this rectangle
		p_width = (width / x_width)

		# If we can fit the label above the column, do that;
		# otherwise, put it inside the column.
		if p_width > 0.50: # arbitrary; 95% looked good to me.
		label_position = width - (x_width * 0.01)
		color = "white"
		align = "right"
		else:
		label_position = width + (x_width * 0.01)

		mono = {'family': 'monospace'}
		ax.text(label_position, rect.get_y(), labels[i], ha=align, va='bottom', rotation=0, color=color, fontdict=mono)

		def _plot_regions(dataset):
		"""
		plot regions, sorted by latency criticality
		"""
		relevant = sorted([x for x in dataset if x['Slowdown'] > 0 and x['Slowdown'] <= 5], key=lambda x: x['Slowdown'])
		x = np.arange(len(relevant))

		correlations = list(map(lambda x: x['Slowdown'], relevant))
		ticks = list(map(lambda x: "<%s,%s>" % (x['Start'][:-2], x['End'][:-2]), relevant))
		fig, ax = plt.subplots()
		rects = ax.barh(x, correlations, align="center", tick_label="")
		autolabel(rects, ax, ticks)

		plt.tight_layout()
		plt.savefig("normalized-slowdown.pdf")
		plt.close()


		def duration_to_string(d):
		return str(d['Start']) + "->" + str(d['Stop'])

		def analyse(df1, df2, config, export=False):
		data1 = df1['EndToEnd_D']
		data2 = df2['EndToEnd_D']
		print("#1 e2e: " + str(np.mean(data1)) + " +- " + str(np.std(data1)))
		print("#2 e2e: " + str(np.mean(data2)) + " +- " + str(np.std(data2)))

		normalize = np.mean(data1) / np.mean(data2)

		dataset = []

		for d in latency.get_durations_2([df1, df2], config):
		local1 = df1[d['Stop']] - df1[d['Start']]
		local2 = df2[d['Stop']] - df2[d['Start']]

		# too short -> ignore
		if np.mean(local1) == 0 or np.mean(local2) == 0:
		continue

		slowdown = np.mean(local1) / np.mean(local2)

		#print(duration_to_string(d)+" "+str(lf) + " / "+str(frac)+ " = " + str(lf/frac))
		#print("\"<"+d['Start']+","+d['Stop']+">\" "+str(slowdown/normalize)+" "+str(slowdown)+" "+str(normalize))
		dataset += [{ 'Start': d['Start'], 'End': d['Stop'], 'Slowdown': slowdown }]

		_plot_regions(dataset)

xlap/analyse/latency.py

+4 −0

Original line number	Diff line number	Diff line
		@@ -204,6 +204,10 @@ def get_durations(df, config):
		hdb += [{'Start': str(event1), 'Stop': str(event2), 'Source': 'cfa'}]
		return hdb

		def get_durations_2(dfs, config):
		df = dfs[0] + dfs[1]
		return get_durations(df, config)

		def analyse(df, config):
		hb = []

xlap/command_line.py

+15 −2

Original line number	Diff line number	Diff line
		@@ -4,11 +4,13 @@ from xlap.parse import evaluate, parse_config
		import xlap.analyse.jitter as jitter
		import xlap.analyse.latency as latency
		import xlap.analyse.diff as difference
		import xlap.analyse.e2e as e2e

		tasks = {
		"jitter": None,
		"latency": None,
		"difference": None,
		"e2e": None,
		"capture": None
		}

		@@ -43,18 +45,29 @@ def main():
		f.write("\n")
		else:
		print(output)
		elif command == "e2e":
		khz1 = 2000000
		khz2 = 3000000
		path="../publications/nsdi-18/eval/20180419_energy/"
		df_data1 = evaluate(path+"sender-"+str(khz1)+".csv", path+"receiver-"+str(khz1)+".csv", config=config, kind=0)
		df_data2 = evaluate(path+"sender-"+str(khz2)+".csv", path+"receiver-"+str(khz2)+".csv", config=config, kind=0)
		e2e.analyse(df_data1, df_data2, config)
		elif command == "latency":
		df_data = evaluate(data_files["sender"], data_files["receiver"], config=config, kind=0)
		a = latency.analyse(df_data, config)
		print(a.corr.sort_values(ascending=False))
		elif command == "difference":
		df_data1 = evaluate("../prrt/out/s.csv", "../prrt/out/r.csv", config=config, kind=0)
		path="../publications/nsdi-18/eval/20180420_"
		khz = 3000000
		df_data1 = evaluate(path+"base1/sender-"+str(khz)+".csv", path+"base1/receiver-"+str(khz)+".csv", config=config, kind=0)
		# sanity check:
		#df_data2 = evaluate("../prrt/out/s.csv", "../prrt/out/r.csv", config=config, kind=0)
		# same setup, different measurement run:
		#df_data2 = evaluate("../prrt/out/s+same.csv", "../prrt/out/r+same.csv", config=config, kind=0)
		# different setup:
		df_data2 = evaluate("../prrt/out/s+send.csv", "../prrt/out/r+send.csv", config=config, kind=0)
		#df_data2 = evaluate("../prrt/out/s+send.csv", "../prrt/out/r+send.csv", config=config, kind=0)
		df_data2 = evaluate(path+"base2/sender-"+str(khz)+".csv", path+"base2/receiver-"+str(khz)+".csv", config=config, kind=0)
		#df_data2 = evaluate(path+"changed/sender-"+str(khz)+".csv", path+"changed/receiver-"+str(khz)+".csv", config=config, kind=0)
		difference.analyse(df_data1, df_data2, config)
		else:
		df_data = evaluate(data_files["sender"], data_files["receiver"], config=config, kind=0)