def plot(args):
plotter = plot_helper.plotter(args)
query = {
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(1),
"$lt": args.date
},
}
df = plotter.get_dataframe(query, "kodo_decoding_probability")
# Calculate the expected number of extra pacekts depending on the rank
df['dependency'] = df['rank'].apply(scipy.mean, axis=0) - 1
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
# Group by type of code; dense, sparse
dense = df[df['testcase'].isin(plot_helper.codes['dense'])].groupby(
by=['slavename', 'symbol_size', 'symbols'])
sparse = df[df['testcase'].isin(plot_helper.codes['sparse'])].groupby(
by=['slavename', 'symbol_size', 'symbols'])
def set_comparison_plot():
#pl.xlim(xmin = max(0, pl.xlim()[1] -16 ))
pyplot.xticks(symbols - 2**scipy.arange(scipy.log2(symbols))[::-1],
2**scipy.arange(scipy.log2(symbols), dtype=int)[::-1])
pyplot.grid('on')
plotter.set_slave_info(slavename)
pyplot.xlabel("Rank Deficiency")
pyplot.ylabel("Extra Packets")
# Verbose plotting since due to no pandas support for plotting of vectors
for (slavename, symbol_size, symbols), group in sparse:
pyplot.figure()
for (deps, field, density) in zip(group['dependency'], group['field'],
group['density']):
pyplot.plot(scipy.arange(symbols),
deps,
marker=plot_helper.get_marker(field),
label="({}, {})".format(field, str(density)))
set_comparison_plot()
plotter.write("sparse", slavename)
for (slavename, symbol_size, symbols), group in dense:
pyplot.figure()
for (deps, field, algorithm) in zip(group['dependency'],
group['field'],
group['algorithm']):
pyplot.plot(scipy.arange(symbols),
deps,
marker=plot_helper.get_marker(field),
label="({}, {})".format(field, algorithm))
set_comparison_plot()
plotter.write("dense", slavename)
return df
def plot(args):
plotter = plot_helper.plotter(args)
query = {
"type": args.coder,
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(1),
"$lt": args.date},
}
df = plotter.get_dataframe(query, "kodo_throughput")
df['mean'] = df['throughput'].apply(scipy.mean)
df['std'] = df['throughput'].apply(scipy.std)
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
df['slavename'] = df['slavename'].apply(plot_helper.get_slave_info)
# Group by type of code; dense, sparse
dense = df[df['testcase'].isin(plot_helper.codes['dense'])].groupby(
by=['field', 'algorithm', 'symbol_size'])
sparse = df[df['testcase'].isin(plot_helper.codes['sparse'])].groupby(
by=['field', 'density', 'symbol_size'])
def plot_setup(p):
pylab.ylabel("Throughput" + " [" + list(group['unit'])[0] + "]")
pylab.yscale('log')
pylab.xscale('log', basex=2)
pylab.xticks(
list(scipy.unique(group['symbols'])),
list(scipy.unique(group['symbols'])))
plotter.set_markers(p)
plotter.set_legend_columns(3)
for (field, density, symbols), group in sparse:
p = group.pivot_table(
'mean', rows='symbols', cols=['slavename',]).plot()
plot_setup(p)
plotter.set_legend_title(
"Field size: {0}, Density: {1}, Symbols: {2}".format(
str(field), str(density),str(symbols)))
plotter.write("sparse", field + "_" + str(density))
for (field, algorithm, symbols), group in dense:
p = group.pivot_table(
'mean', rows='symbols', cols=['slavename']).plot()
plot_setup(p)
plotter.set_legend_title(
"Field size: {0}, Algorithm: {1}, Symbols: {2}".format(
str(field), str(algorithm),str(symbols)))
plotter.write("dense", field + "_" + algorithm)
return df
def plot(args):
plotter = plot_helper.plotter(args)
query = {
"type": args.coder,
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(60),
"$lt": args.date},
}
df = plotter.get_dataframe(query, "kodo_throughput")
df['mean'] = df['throughput'].apply(scipy.mean)
df['std'] = df['throughput'].apply(scipy.std)
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
df['slavename'] = df['slavename'].apply(plot_helper.replace_underscore)
df['date'] = df['utc_date'].apply(plot_helper.pandas.datetime.date)
df = df.set_index(df['date'])
# Group by type of code; dense, sparse
dense = df[df['testcase'].isin(plot_helper.codes['dense'])].groupby(
by=['slavename', 'symbols', 'symbol_size'])
sparse = df[df['testcase'].isin(plot_helper.codes['sparse'])].groupby(
by=['slavename', 'symbols', 'symbol_size'])
def plot_setup(p):
pylab.ylabel("Throughput" + " [" + list(group['unit'])[0] + "]")
pylab.yscale('log')
pylab.xscale('log', basex=2)
pylab.xticks(
list(scipy.unique(group['symbols'])),
list(scipy.unique(group['symbols'])))
plotter.set_markers(p)
plotter.set_slave_info(slavename)
for (slavename, symbols, symbol_size), group in sparse:
p = group.pivot_table(
'mean', rows='date', cols=['field', 'density']).plot(use_index = True)
plot_setup(p)
plotter.set_legend_title("(Field, Density)")
plotter.write("sparse", str(slavename) + "_" + str(symbols))
for (slavename, symbols, symbol_size), group in dense:
p = group.pivot_table(
'mean', rows='date', cols=['field', 'algorithm']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Algorithm)")
plotter.write("dense", str(slavename) + "_" + str(symbols))
return df
def plot(args):
plotter = plot_helper.plotter(args)
query = {
"type": args.coder,
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(1),
"$lt": args.date
},
}
df = plotter.get_dataframe(query, "kodo_throughput")
df['mean'] = df['throughput'].apply(scipy.mean)
df['std'] = df['throughput'].apply(scipy.std)
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
# Group by type of code; dense, sparse
dense = df[df['testcase'].isin(
plot_helper.codes['dense'])].groupby(by=['slavename', 'symbol_size'])
sparse = df[df['testcase'].isin(
plot_helper.codes['sparse'])].groupby(by=['slavename', 'symbol_size'])
def plot_setup(p):
pylab.ylabel("Throughput" + " [" + list(group['unit'])[0] + "]")
pylab.yscale('log')
pylab.xscale('log', basex=2)
pylab.xticks(list(scipy.unique(group['symbols'])),
list(scipy.unique(group['symbols'])))
plotter.set_markers(p)
plotter.set_slave_info(slavename)
for (slavename, symbols), group in sparse:
p = group.pivot_table('mean',
rows='symbols',
cols=['field', 'density']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Algorithm)")
plotter.write("sparse", slavename)
for (slavename, symbols), group in dense:
p = group.pivot_table('mean',
rows='symbols',
cols=['field', 'algorithm']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Density)")
plotter.write("dense", slavename)
return df
def plot(args):
plotter = plot_helper.plotter(args)
query = {
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(1),
"$lt": args.date
}
}
df = plotter.get_dataframe(query, "kodo_decoding_probability")
df['mean'] = df['used'].apply(scipy.mean) - df['symbols']
df['std'] = df['used'].apply(scipy.std)
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
dense = df[df['testcase'].isin(plot_helper.codes['dense'])].groupby(
by=['slavename', 'symbol_size'])
sparse = df[df['testcase'].isin(plot_helper.codes['sparse'])].groupby(
by=['slavename', 'symbol_size'])
def plot_setup(p):
pylab.ylabel("Extra symbols [{}]".format(list(group['unit'])[0]))
pylab.xscale('log', basex=2)
pylab.xticks(list(scipy.unique(group['symbols'])))
plotter.set_slave_info(slavename)
plotter.set_markers(p)
for (slavename, symbols), group in sparse:
p = group.pivot_table('mean', rows='symbols', cols=['field',
'density']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Density)")
plotter.write("sparse", slavename)
for (slavename, symbols), group in dense:
p = group.pivot_table(
'mean',
rows='symbols',
cols=['field', 'algorithm']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Algorithm)")
plotter.write("dense", slavename)
return df
def plot(args):
plotter = plot_helper.plotter(args)
query = {
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(1),
"$lt": args.date},
}
df = plotter.get_dataframe(query, "kodo_decoding_probability")
# Calculate the expected number of extra pacekts depending on the rank
df['dependency'] = df['rank'].apply(scipy.mean, axis=0) - 1
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
# Group by type of code; dense, sparse
dense = df[df['testcase'].isin(plot_helper.codes['dense'])].groupby(
by=['slavename', 'symbol_size', 'symbols'])
sparse = df[df['testcase'].isin(plot_helper.codes['sparse'])].groupby(
by=['slavename', 'symbol_size', 'symbols'])
def set_comparison_plot():
#pl.xlim(xmin = max(0, pl.xlim()[1] -16 ))
pyplot.xticks(
symbols - 2 ** scipy.arange(scipy.log2(symbols))[::-1],
2 ** scipy.arange(scipy.log2(symbols), dtype=int)[::-1])
pyplot.grid('on')
plotter.set_slave_info(slavename)
pyplot.xlabel("Rank Deficiency")
pyplot.ylabel("Extra Packets")
# Verbose plotting since due to no pandas support for plotting of vectors
for (slavename, symbol_size, symbols), group in sparse:
pyplot.figure()
for (deps, field, density) in zip(group['dependency'], group['field'],
group['density']):
pyplot.plot(
scipy.arange(symbols),
deps,
marker=plot_helper.get_marker(field),
label="({}, {})".format(field, str(density)))
set_comparison_plot()
plotter.write("sparse", slavename)
for (slavename, symbol_size, symbols), group in dense:
pyplot.figure()
for (deps, field, algorithm) in zip(
group['dependency'],
group['field'],
group['algorithm']):
pyplot.plot(
scipy.arange(symbols),
deps,
marker=plot_helper.get_marker(field),
label="({}, {})".format(field, algorithm))
set_comparison_plot()
plotter.write("dense", slavename)
return df
def plot(args):
plotter = plot_helper.plotter(args)
query_branches = {
"type": args.coder,
"scheduler": "force kodo (benchmark)",
"utc_date": {"$gte": args.date - plot_helper.timedelta(1)}
}
query_master = {
"type": args.coder,
"branch": "master",
"scheduler": "kodo (nightly benchmark)",
"utc_date": {
"$gte": args.date - plot_helper.timedelta(1),
"$lt": args.date}
}
df_master = plotter.get_dataframe(query_master, "kodo_throughput")
df_branches = plotter.get_dataframe(query_branches, "kodo_throughput")
df = df_master.append(df_branches)
df['mean'] = df['throughput'].apply(scipy.mean)
df['std'] = df['throughput'].apply(scipy.std)
df['field'] = df['benchmark'].apply(plot_helper.get_field)
df['algorithm'] = df['testcase'].apply(plot_helper.get_algorithm)
groups = df.groupby(['slavename'])
branches = list(scipy.unique(df['branch']))
if len(branches) == 1:
print("Only recent benchmarks for the master branch in the database, "
"no plots will be generated.")
plotter = plot_helper.plotter(args)
for slavename, group in groups:
# Group all results from the most recent master build
master_group = group[scipy.array(group['branch'] == "master")]
group[group['branch'] == "master"]
if len(master_group) == 0:
print "Skipping " + slavename + " as no nightly benchmark results \
exists for the master for this buider yet"
continue
master_group = master_group[master_group['buildnumber'] ==
max(master_group['buildnumber'])]
# Group all other results by branch
branches_group = group[
group['branch'] != "master"].groupby(by=['branch'])
for branch, branch_group in branches_group:
plotter.set_branch(branch)
# Calculate the difference compared to master of the latest build
branch_group = branch_group[branch_group["buildnumber"]
== max(branch_group['buildnumber'])]
master_mean = scipy.array(master_group['mean'])
branch_mean = scipy.array(branch_group['mean'])
branch_group['gain'] = \
(branch_mean - master_mean) / master_mean * 100
# Group by type of code; dense, sparse
dense = branch_group[branch_group['testcase'].isin(
plot_helper.codes['dense'])].groupby(by=['symbol_size'])
sparse = branch_group[branch_group['testcase'].isin(
plot_helper.codes['sparse'])].groupby(by=['symbol_size'])
def plot_setup(p):
pylab.ylabel("Throughput gain [\%]")
pylab.xscale('log', basex=2)
pylab.xticks(
list(scipy.unique(group['symbols'])),
list(scipy.unique(group['symbols'])))
plotter.set_markers(p)
plotter.set_slave_info(slavename)
for symbols, group in sparse:
p = group.pivot_table(
'gain',
rows='symbols',
cols=['field', 'density']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Density)")
plotter.write("sparse", slavename)
for symbols, group in dense:
p = group.pivot_table('gain', rows='symbols',
cols=['field', 'algorithm']).plot()
plot_setup(p)
plotter.set_legend_title("(Field, Algorithm)")
plotter.write("dense", slavename)
return df
