def generate_threshold(jgraphs, benchmark, stat, ylabel, transformation, ymax):
## Generate threshold variation
lines = []
for module in ["MOSI_bcast_opt", "MOSI_GS"]:
points = []
for bandwidth in bandwidth_list:
value = mfgraph.average(get_data(benchmark, module=module, bandwidth=bandwidth, stat=stat))
if (value != []):
points.append([bandwidth, value])
lines.append([module] + points)
for threshold in threshold_list:
points = []
for bandwidth in bandwidth_list:
value = mfgraph.average(get_data(benchmark, module="MOSI_mcast_aggr", bandwidth=bandwidth, threshold=threshold, stat=stat))
if (value != []):
points.append([bandwidth, value])
if threshold == default_threshold:
lines.append(["MOSI_mcast_aggr"] + points)
else:
lines.append(["%f" % threshold] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraphs.append(mfgraph.line_graph(lines,
title = "multiple thresholds: %s vs %s - %d processors" % (xlabel, ylabel, default_processor),
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
xlog = 10,
xmin = 90.0
))
def generate_processors(jgraphs, benchmark, stat, ylabel, transformation,
ymax):
## Generate number of processors vs performance (one graph per bandwidth)
for bandwidth in bandwidth_list:
lines = []
for module in modules_list:
points = []
counter = 2
for processor in processor_list:
data = get_data(benchmark,
processor=processor,
module=module,
bandwidth=bandwidth,
stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
points.append(
[counter, value, value - stddev, value + stddev])
counter += 1
lines.append([module] + points)
transformation(lines)
xlabel = "processor count"
jgraphs.append(
mfgraph.line_graph(
lines,
title="%s vs %s - %d bandwidth" % (xlabel, ylabel, bandwidth),
xlabel=xlabel,
ylabel=ylabel,
ymax=ymax,
xmin=1.9,
))
def generate_thinktime(jgraphs, benchmark, stat, ylabel, transformation, ymax):
for bandwidth in bandwidth_list:
lines = []
for module in modules_list:
points = []
for think_time in think_time_list:
value = mfgraph.average(
get_data(benchmark,
module=module,
bandwidth=bandwidth,
think_time=think_time,
stat=stat))
if (value != []):
points.append([think_time, value])
lines.append([module] + points)
transformation(lines)
xlabel = "think time"
jgraphs.append(
mfgraph.line_graph(
lines,
title="%s vs %s - %d bandwidth" % (xlabel, ylabel, bandwidth),
xlabel=xlabel,
ylabel=ylabel,
ymax=ymax,
))
def generate_processors(jgraphs, benchmark, stat, ylabel, transformation, ymax):
## Generate number of processors vs performance (one graph per bandwidth)
for bandwidth in bandwidth_list:
lines = []
for module in modules_list:
points = []
counter = 2
for processor in processor_list:
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
points.append([counter, value, value - stddev, value + stddev])
counter += 1
lines.append([module] + points)
transformation(lines)
xlabel = "processor count"
jgraphs.append(mfgraph.line_graph(lines,
title = "%s vs %s - %d bandwidth" % (xlabel, ylabel, bandwidth),
xlabel = xlabel,
ylabel = ylabel,
ymax = ymax,
xmin = 1.9,
))
def generate_bandwidth(jgraphs, benchmark, stat, ylabel, transformation, ymax):
## Generate bandwidth available vs performance (one graph per processor count)
for processor in processor_list:
lines = []
for module in modules_list:
points = []
for bandwidth in bandwidth_list:
data = get_data(benchmark,
processor=processor,
module=module,
bandwidth=bandwidth,
stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
points.append(
[bandwidth, value, value + stddev, value - stddev])
lines.append([module] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraphs.append(
mfgraph.line_graph(lines,
title="%s: %d processors" %
(benchmark, processor),
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
xlog=10,
xmin=90.0))
def generate_threshold(jgraphs, benchmark, stat, ylabel, transformation, ymax):
## Generate threshold variation
lines = []
for module in ["MOSI_bcast_opt", "MOSI_GS"]:
points = []
for bandwidth in bandwidth_list:
value = mfgraph.average(
get_data(benchmark,
module=module,
bandwidth=bandwidth,
stat=stat))
if (value != []):
points.append([bandwidth, value])
lines.append([module] + points)
for threshold in threshold_list:
points = []
for bandwidth in bandwidth_list:
value = mfgraph.average(
get_data(benchmark,
module="MOSI_mcast_aggr",
bandwidth=bandwidth,
threshold=threshold,
stat=stat))
if (value != []):
points.append([bandwidth, value])
if threshold == default_threshold:
lines.append(["MOSI_mcast_aggr"] + points)
else:
lines.append(["%f" % threshold] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraphs.append(
mfgraph.line_graph(
lines,
title="multiple thresholds: %s vs %s - %d processors" %
(xlabel, ylabel, default_processor),
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
xlog=10,
xmin=90.0))
def generate_micro4(stat, ylabel, transformation, ymax, legend_x, legend_y):
benchmark = "microbenchmark"
processor = 64
## Generate bandwidth available vs performance (one graph per processor count)
for bandwidth in bandwidth_list:
jgraph_input = ""
lines = []
for module in modules_list:
points = []
for think_time in think_time_list:
if think_time > 1000:
continue
data = get_data(benchmark,
think_time=think_time,
processor=processor,
module=module,
bandwidth=bandwidth,
stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
if (stat == "Ruby_cycles"):
points.append([
think_time, ((value / 10000.0) - think_time) / 2.0
])
else:
points.append([think_time, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "think time (cycles)"
jgraph_input += mfgraph.line_graph(
lines,
title_fontsize="12",
title_font="Times-Roman",
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
label_fontsize="9",
xsize=1.8,
ysize=1.8,
xmin=0.0,
legend_x=legend_x,
legend_y=legend_y,
legend_fontsize="8",
# marktype = ["circle"],
# marksize = .03,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 1000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 950 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(
jgraph_input, "bash-microbenchmark-thinktime-%d-%s" %
(bandwidth, string.split(ylabel)[0]))
def generate_macro_bar():
processor = 16
bandwidth = 1600
stat = "Ruby_cycles"
stacks = []
for benchmark in benchmarks[1:]:
bars = []
modules = ["MOSI_bcast_opt_4", "MOSI_GS_4", "MOSI_mcast_aggr_4"]
#norm = mfgraph.average(get_data(benchmark, processor=processor, module="MOSI_mcast_aggr_4", bandwidth=bandwidth, stat=stat))
norm = mfgraph.average(get_data(benchmark, processor=processor, module="MOSI_bcast_opt_4", bandwidth=bandwidth, stat=stat))
for module in modules:
if module == "MOSI_mcast_aggr_4":
bars.append(["", 0])
else:
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
if (stddev/value)*100.0 > 1.0: # only plot error bars if they are more than 1%
bars.append([protocol_name[module], [norm/value, norm/(value+stddev), norm/(value-stddev)]])
else:
bars.append([protocol_name[module], [norm/value, norm/(value+stddev), norm/(value-stddev)]])
# bars.append([protocol_name[module], norm/value])
stacks.append([workload_name[benchmark]] + bars)
jgraph_input = mfgraph.stacked_bar_graph(stacks,
colors = ["1 0 0", "0 .5 0", "0 0 1", "0 1 1", "1 0 1"],
# colors = [".85 .85 .85", ".5 .5 .5", ".45 .45 .45"],
patterns = ["solid", "stripe -45"],
ymax = 1.5,
xsize = 2.7,
ysize = 2.3,
label_fontsize = "9",
hash_label_fontsize = "9",
stack_name_font_size = "9",
bar_name_font_size = "9",
bar_name_rotate = 90.0,
stack_name_location = 28.0,
ylabel = "normalized performance",
yhash = 0.2,
ymhash = 1,
)
mfgraph.run_jgraph(jgraph_input, "bash-macro-talk-bars")
def generate_micro3(stat, ylabel, transformation, ymax, legend_x, legend_y):
benchmark = "microbenchmark"
## Generate bandwidth available vs performance (one graph per processor count)
for bandwidth in bandwidth_list:
jgraph_input = ""
lines = []
for module in modules_list:
points = []
for processor in processor_list:
data = get_data(benchmark,
processor=processor,
module=module,
bandwidth=bandwidth,
stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([processor, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "processors"
if ylabel == "performance":
ylabel = "performance per processor"
jgraph_input += mfgraph.line_graph(
lines,
title_fontsize="12",
title_font="Times-Roman",
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
label_fontsize="9",
xsize=1.8,
ysize=1.8,
xlog=10,
xmin=3.0,
legend_x=4,
legend_y=legend_y,
legend_fontsize="8",
marktype=["circle"],
marksize=.03,
hash_marks=map(str, processor_list),
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 512 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 512 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(
jgraph_input, "bash-microbenchmark-processors-%d-%s" %
(bandwidth, string.split(ylabel)[0]))
def generate_micro1(stat, ylabel, transformation, ymax, legend_x, legend_y):
jgraph_input = ""
## Generate bandwidth available vs performance (one graph per processor count)
benchmark = "microbenchmark"
processor = 64
lines = []
for module in modules_list:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
data = get_data(benchmark,
processor=processor,
module=module,
bandwidth=bandwidth,
stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(
lines,
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
label_fontsize="9",
xsize=1.8,
ysize=1.8,
xlog=10,
xmin=90.0,
xmax=30000.0,
legend_x=legend_x,
legend_y=legend_y,
legend_fontsize="8",
ylabel_location=18.0,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 200000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 20000 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(
jgraph_input,
"bash-microbench-basic-%d-%s" % (processor, string.split(ylabel)[0]))
def generate_micro4(stat, ylabel, transformation, ymax, legend_x, legend_y):
benchmark = "microbenchmark"
processor = 64
## Generate bandwidth available vs performance (one graph per processor count)
for bandwidth in bandwidth_list:
jgraph_input = ""
lines = []
for module in modules_list:
points = []
for think_time in think_time_list:
if think_time > 1000:
continue
data = get_data(benchmark, think_time=think_time, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
if (stat == "Ruby_cycles"):
points.append([think_time, ((value/10000.0)-think_time)/2.0])
else:
points.append([think_time, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "think time (cycles)"
jgraph_input += mfgraph.line_graph(lines,
title_fontsize = "12",
title_font = "Times-Roman",
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xmin = 0.0,
legend_x = legend_x,
legend_y = legend_y,
legend_fontsize = "8",
# marktype = ["circle"],
# marksize = .03,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 1000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 950 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(jgraph_input, "bash-microbenchmark-thinktime-%d-%s" % (bandwidth, string.split(ylabel)[0]))
def generate_micro3(stat, ylabel, transformation, ymax, legend_x, legend_y):
benchmark = "microbenchmark"
## Generate bandwidth available vs performance (one graph per processor count)
for bandwidth in bandwidth_list:
jgraph_input = ""
lines = []
for module in modules_list:
points = []
for processor in processor_list:
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([processor, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "processors"
if ylabel == "performance":
ylabel = "performance per processor"
jgraph_input += mfgraph.line_graph(lines,
title_fontsize = "12",
title_font = "Times-Roman",
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xlog = 10,
xmin = 3.0,
legend_x = 4,
legend_y = legend_y,
legend_fontsize = "8",
marktype = ["circle"],
marksize = .03,
hash_marks = map(str, processor_list),
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 512 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 512 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(jgraph_input, "bash-microbenchmark-processors-%d-%s" % (bandwidth, string.split(ylabel)[0]))
def generate_thinktime(jgraphs, benchmark, stat, ylabel, transformation, ymax):
for bandwidth in bandwidth_list:
lines = []
for module in modules_list:
points = []
for think_time in think_time_list:
value = mfgraph.average(get_data(benchmark, module=module, bandwidth=bandwidth, think_time=think_time, stat=stat))
if (value != []):
points.append([think_time, value])
lines.append([module] + points)
transformation(lines)
xlabel = "think time"
jgraphs.append(mfgraph.line_graph(lines,
title = "%s vs %s - %d bandwidth" % (xlabel, ylabel, bandwidth),
xlabel = xlabel,
ylabel = ylabel,
ymax = ymax,
))
def generate_micro1(stat, ylabel, transformation, ymax, legend_x, legend_y):
jgraph_input = ""
## Generate bandwidth available vs performance (one graph per processor count)
benchmark = "microbenchmark"
processor = 64
lines = []
for module in modules_list:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(lines,
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xlog = 10,
xmin = 90.0,
xmax = 30000.0,
legend_x = legend_x,
legend_y = legend_y,
legend_fontsize = "8",
ylabel_location = 18.0,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 200000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 20000 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(jgraph_input, "bash-microbench-basic-%d-%s" % (processor, string.split(ylabel)[0]))
def make_bars(fields, data):
if (len(fields) <= 0):
return
map = {}
for field in fields:
map[field] = {}
for tuple in data:
fCnt = 1
for field in fields:
#print field
key = tuple[0]
#print "key: %d" % key
if map[field].has_key(key):
dummy = 0
else:
map[field][key] = []
map[field][key].append(tuple[fCnt])
fCnt += 1
fField = fields[0]
tuple_list = []
for key in map[fField].keys():
tuple = [key]
for field in fields:
avg_val = mfgraph.average(map[field][key])
if avg_val < 0:
print "Error: entering negative avg val for %s at %dp" % (
field, key)
tuple.append(avg_val)
#print tuple
#stacked_tuple = [key] + mfgraph.stack_bars(tuple)
tuple_list.append(tuple)
return tuple_list
def generate_bandwidth(jgraphs, benchmark, stat, ylabel, transformation, ymax):
## Generate bandwidth available vs performance (one graph per processor count)
for processor in processor_list:
lines = []
for module in modules_list:
points = []
for bandwidth in bandwidth_list:
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
points.append([bandwidth, value, value+stddev, value-stddev])
lines.append([module] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraphs.append(mfgraph.line_graph(lines,
title = "%s: %d processors" % (benchmark, processor),
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
xlog = 10,
xmin = 90.0
))
def make_bars(fields, data):
if(len(fields) <= 0):
return
map = {}
for field in fields:
map[field] = {}
for tuple in data:
fCnt = 1
for field in fields:
#print field
key = tuple[0]
#print "key: %d" % key
if map[field].has_key(key):
dummy = 0
else:
map[field][key] = []
map[field][key].append(tuple[fCnt])
fCnt += 1
fField = fields[0]
tuple_list = []
for key in map[fField].keys():
tuple = [key]
for field in fields:
avg_val = mfgraph.average(map[field][key])
if avg_val < 0: print "Error: entering negative avg val for %s at %dp" % (field, key)
tuple.append(avg_val)
#print tuple
#stacked_tuple = [key] + mfgraph.stack_bars(tuple)
tuple_list.append(tuple)
return tuple_list
def generate_micro1(stat, ylabel, transformation, ymax, legend_x, legend_y):
jgraph_input = ""
## Generate bandwidth available vs performance (one graph per processor count)
benchmark = "microbenchmark"
processor = 64
lines = []
for module in ["MOSI_bcast_opt_1", "MOSI_GS_1"]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(lines,
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xlog = 10,
xmin = 90.0,
xmax = 30000.0,
legend_x = legend_x,
legend_y = legend_y,
legend_fontsize = "8",
ylabel_location = 18.0,
colors = ["1 0 0", "0 .5 0", "0 1 1", "1 0 1"],
linetype = ["dotted", "longdash", "dotdash", "dashed"],
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 200000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 20000 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(jgraph_input, "bash-microbench-talk-two-%d-%s" % (processor, string.split(ylabel)[0]))
############ repeated code
jgraph_input = ""
## Generate bandwidth available vs performance (one graph per processor count)
benchmark = "microbenchmark"
processor = 64
lines = []
for module in modules_list:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(lines,
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xlog = 10,
xmin = 90.0,
xmax = 30000.0,
legend_x = legend_x,
legend_y = legend_y,
legend_fontsize = "8",
ylabel_location = 18.0,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 200000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 20000 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(jgraph_input, "bash-microbench-talk-three-%d-%s" % (processor, string.split(ylabel)[0]))
############ repeated code
jgraph_input = ""
## Generate bandwidth available vs performance (one graph per processor count)
benchmark = "microbenchmark"
processor = 64
lines = []
for module in ["MOSI_bcast_opt_1", "maximum", "MOSI_GS_1"]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
if module == "maximum":
data1 = get_data(benchmark, processor=processor, module="MOSI_bcast_opt_1", bandwidth=bandwidth, stat=stat)
data2 = get_data(benchmark, processor=processor, module="MOSI_GS_1", bandwidth=bandwidth, stat=stat)
if len(data1) > 0:
value1 = mfgraph.average(data1)
if len(data2) > 0:
value2 = mfgraph.average(data2)
value = min([value1, value2])
points.append([bandwidth, value])
else:
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(lines,
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xlog = 10,
xmin = 90.0,
xmax = 30000.0,
legend_x = legend_x,
legend_y = legend_y,
legend_fontsize = "8",
ylabel_location = 18.0,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 200000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 20000 y 76 fontsize 8 : 75%\n"
mfgraph.run_jgraph(jgraph_input, "bash-microbench-talk-three-max-%d-%s" % (processor, string.split(ylabel)[0]))
def generate_micro2(stat, ylabel, transformation, ymax, legend_x, legend_y):
jgraph_input = ""
## Generate threshold variation
benchmark = "microbenchmark"
processor = 64
lines = []
for module in ["MOSI_bcast_opt_1"]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
value = mfgraph.average(
get_data(benchmark,
module=module,
bandwidth=bandwidth,
stat=stat))
if (value != 0):
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
for threshold in [0.55, 0.75, 0.95]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
value = mfgraph.average(
get_data(benchmark,
module="MOSI_mcast_aggr_1",
bandwidth=bandwidth,
threshold=threshold,
stat=stat))
if (value != 0):
points.append([bandwidth, value])
lines.append([
protocol_name["MOSI_mcast_aggr_1"] + ": %2.0f%%" %
(threshold * 100)
] + points)
for module in ["MOSI_GS_1"]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
value = mfgraph.average(
get_data(benchmark,
module=module,
bandwidth=bandwidth,
stat=stat))
if (value != 0):
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
global norm_module
old_norm_module = norm_module
norm_module = protocol_name["MOSI_mcast_aggr_1"] + ": %2.0f%%" % (
default_threshold * 100)
transformation(lines)
norm_module = old_norm_module
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(
lines,
title_fontsize="12",
title_font="Times-Roman",
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
label_fontsize="9",
xsize=1.8,
ysize=1.8,
xlog=10,
xmin=90.0,
xmax=30000.0,
legend_x=legend_x,
legend_y=legend_y,
legend_fontsize="8",
ylabel_location=18.0,
)
mfgraph.run_jgraph(
jgraph_input, "bash-microbench-threshold-%d-%s" %
(processor, string.split(ylabel)[0]))
def generate_macro(scale, benchmarks, stat, ylabel, transformation, ymax):
cols = 3
row_space = 2.2
col_space = 2.3
jgraph_input = ""
num = 0
## Generate bandwidth available vs performance (one graph per processor count)
for benchmark in benchmarks:
processor = 16
lines = []
if scale == 4:
modules = "MOSI_bcast_opt_4", "MOSI_mcast_aggr_4", "MOSI_GS_4",
if scale == 1:
modules = "MOSI_bcast_opt_1", "MOSI_mcast_aggr_1", "MOSI_GS_1",
for module in modules:
points = []
for bandwidth in bandwidth_list:
if bandwidth < 600:
continue
if bandwidth > 12800:
continue
data = get_data(benchmark, processor=processor, module=module, bandwidth=bandwidth, stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
if (stddev/value)*100.0 > 1.0 and benchmark != "microbenchmark": # only plot error bars if they are more than 1%
points.append([bandwidth, value, value+stddev, value-stddev])
else:
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
# don't plot marks for the microbenchmark
benchmark_marktype = ["circle"]
if benchmark == "microbenchmark":
benchmark_marktype = ["none"]
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(lines,
#title = "%s: %dx%d processors" % (workload_name[benchmark], scale, processor),
title = "%s" % (workload_name[benchmark]),
title_fontsize = "10",
title_font = "Times-Roman",
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.4,
xlog = 10,
xmin = 450.0,
xmax = 12800.0,
legend_x = "2500",
legend_y = ".18",
legend_fontsize = "8",
marktype = benchmark_marktype,
marksize = .03,
x_translate = (num % cols) * col_space,
y_translate = (num / cols) * -row_space,
ylabel_location = 18.0,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 11000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 10000 y 76 fontsize 8 : 75%\n"
num += 1
mfgraph.run_jgraph(jgraph_input, "bash-macrobenchmarks-%d-%s" % (scale, string.split(ylabel)[0]))
def generate_macro(scale, benchmarks, stat, ylabel, transformation, ymax):
cols = 3
row_space = 2.2
col_space = 2.3
jgraph_input = ""
num = 0
## Generate bandwidth available vs performance (one graph per processor count)
for benchmark in benchmarks:
processor = 16
lines = []
if scale == 4:
modules = "MOSI_bcast_opt_4", "MOSI_mcast_aggr_4", "MOSI_GS_4",
if scale == 1:
modules = "MOSI_bcast_opt_1", "MOSI_mcast_aggr_1", "MOSI_GS_1",
for module in modules:
points = []
for bandwidth in bandwidth_list:
if bandwidth < 600:
continue
if bandwidth > 12800:
continue
data = get_data(benchmark,
processor=processor,
module=module,
bandwidth=bandwidth,
stat=stat)
if len(data) > 0:
value = mfgraph.average(data)
stddev = mfgraph.stddev(data)
if (
stddev / value
) * 100.0 > 1.0 and benchmark != "microbenchmark": # only plot error bars if they are more than 1%
points.append(
[bandwidth, value, value + stddev, value - stddev])
else:
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
transformation(lines)
# don't plot marks for the microbenchmark
benchmark_marktype = ["circle"]
if benchmark == "microbenchmark":
benchmark_marktype = ["none"]
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(
lines,
#title = "%s: %dx%d processors" % (workload_name[benchmark], scale, processor),
title="%s" % (workload_name[benchmark]),
title_fontsize="10",
title_font="Times-Roman",
ymax=ymax,
xlabel=xlabel,
ylabel=ylabel,
label_fontsize="9",
xsize=1.8,
ysize=1.4,
xlog=10,
xmin=450.0,
xmax=12800.0,
legend_x="2500",
legend_y=".18",
legend_fontsize="8",
marktype=benchmark_marktype,
marksize=.03,
x_translate=(num % cols) * col_space,
y_translate=(num / cols) * -row_space,
ylabel_location=18.0,
)
if stat == "links_utilized_percent":
jgraph_input += "newcurve clip pts 0.1 75 11000 75 linetype solid linethickness 1 marktype none gray .75\n"
jgraph_input += "newstring x 10000 y 76 fontsize 8 : 75%\n"
num += 1
mfgraph.run_jgraph(
jgraph_input,
"bash-macrobenchmarks-%d-%s" % (scale, string.split(ylabel)[0]))
def generate_micro2(stat, ylabel, transformation, ymax, legend_x, legend_y):
jgraph_input = ""
## Generate threshold variation
benchmark = "microbenchmark"
processor = 64
lines = []
for module in ["MOSI_bcast_opt_1"]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
value = mfgraph.average(get_data(benchmark, module=module, bandwidth=bandwidth, stat=stat))
if (value != 0):
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
for threshold in [0.55, 0.75, 0.95]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
value = mfgraph.average(get_data(benchmark, module="MOSI_mcast_aggr_1", bandwidth=bandwidth, threshold=threshold, stat=stat))
if (value != 0):
points.append([bandwidth, value])
lines.append([protocol_name["MOSI_mcast_aggr_1"] + ": %2.0f%%" % (threshold*100)] + points)
for module in ["MOSI_GS_1"]:
points = []
for bandwidth in bandwidth_list:
if bandwidth > 30000:
continue
value = mfgraph.average(get_data(benchmark, module=module, bandwidth=bandwidth, stat=stat))
if (value != 0):
points.append([bandwidth, value])
lines.append([protocol_name[module]] + points)
global norm_module
old_norm_module = norm_module
norm_module = protocol_name["MOSI_mcast_aggr_1"] + ": %2.0f%%" % (default_threshold*100)
transformation(lines)
norm_module = old_norm_module
xlabel = "endpoint bandwidth available (MB/second)"
jgraph_input += mfgraph.line_graph(lines,
title_fontsize = "12",
title_font = "Times-Roman",
ymax = ymax,
xlabel = xlabel,
ylabel = ylabel,
label_fontsize = "9",
xsize = 1.8,
ysize = 1.8,
xlog = 10,
xmin = 90.0,
xmax = 30000.0,
legend_x = legend_x,
legend_y = legend_y,
legend_fontsize = "8",
ylabel_location = 18.0,
)
mfgraph.run_jgraph(jgraph_input, "bash-microbench-threshold-%d-%s" % (processor, string.split(ylabel)[0]))
