def plotco(lang, smem_default=False, norm=True):
desc = 'gpu' if lang == 'cuda' else 'cpu'
if lang == 'c':
smem_default=False
fig, ax = plt.subplots()
miny = None
linestyle = ''
plot_std = False
nco_marker = 'o'
co_marker = 's'
#pyjac
plotdata1 = [x for x in data if not x.finite_difference
and x.lang == lang
and not x.cache_opt
and x.smem==smem_default]
plotdata2 = [x for x in data if not x.finite_difference
and x.lang == lang
and x.cache_opt
and x.smem==smem_default]
if norm:
xvals = sorted(list(set([p.num_reacs for p in plotdata1] + [p.num_reacs for p in plotdata2])))
def get_y(plotdata, x):
return np.mean(next(pd for pd in plotdata if pd.num_reacs == x).y)
ymax = [max(get_y(plotdata1, x), get_y(plotdata2, x)) for x in xvals]
for i, x in enumerate(xvals):
for pd in [pdtest for pdtest in plotdata1 + plotdata2 if pdtest.num_reacs == x]:
pd.y = np.array(pd.y / ymax[i])
def fake_norm(x):
return np.array(x.y)
thenorm = None if not norm else fake_norm
miny = plot(plotdata1, nco_marker, 'Non Cache-Optimized', miny, norm=thenorm)
miny = plot(plotdata2, nco_marker, 'Cache-Optimized', miny, norm=thenorm)
if not norm:
ax.set_yscale('log')
ax.set_ylim(ymin=miny*0.95)
ax.legend(loc=0, numpoints=1)
# add some text for labels, title and axes ticks
ax.set_ylabel('Mean evaluation time / condition (ms)')
#ax.set_title('GPU Jacobian Evaluation Performance for {} mechanism'.format(thedir))
ax.set_xlabel('Number of reactions')
#ax.legend(loc=0)
plt.savefig('cache_opt_{}.pdf'.format(desc))
plt.close()
def fullscale_comp(lang,
plot_std=True,
homedir=None,
cache_opt_default=False,
smem_default=False,
loc_override=None,
text_loc=None,
fontsize=10,
color_list=['b', 'g', 'r', 'k']):
if lang == 'c':
langs = ['c', 'tchem']
desc = 'cpu'
smem_default = False
elif lang == 'cuda':
langs = ['cuda']
desc = 'gpu'
else:
raise Exception('unknown lang {}'.format(lang))
def thefilter(x):
return x.cache_opt == cache_opt_default and x.smem == smem_default
fit_vals = []
data = get_data(homedir)
data = [x for x in data if x.lang in langs]
data = filter(thefilter, data)
data = get_fullscale(data)
if not len(data):
print 'no data found... exiting'
sys.exit(-1)
fig, ax = plt.subplots()
miny = None
linestyle = ''
fitvals = []
retdata = []
color_ind = 0
text_ind = None
if text_loc:
text_ind = 0
#FD
plotdata = [x for x in data if x.finite_difference]
if plotdata:
color = color_list[color_ind]
color_ind += 1
miny, they, thez = plot(plotdata,
FD_marker,
'Finite Difference',
miny,
return_y=True,
color=color)
theloc = None
if text_ind is not None:
theloc = text_loc[text_ind]
text_ind += 1
fitvals.append(
fit_order(plotdata,
they,
thez,
None,
color,
text_loc=theloc,
fontsize=fontsize))
retdata.append(they)
for lang in langs:
plotdata = [
x for x in data if not x.finite_difference and x.lang == lang
]
color = color_list[color_ind]
color_ind += 1
if plotdata:
name, marker = nice_names(plotdata[0])
miny, they, thez = plot(plotdata,
marker,
name,
miny,
return_y=True,
color=color)
theloc = None
if text_ind is not None:
theloc = text_loc[text_ind]
text_ind += 1
fitvals.append(
fit_order(plotdata,
they,
thez,
None,
color,
text_loc=theloc,
fontsize=fontsize))
retdata.append(they)
ax.set_yscale('log')
ax.set_ylim(ymin=miny * 0.95)
loc = 0 if loc_override is None else loc_override
ax.legend(loc=loc, numpoints=1, fontsize=10)
# add some text for labels, title and axes ticks
ax.set_ylabel('Mean evaluation time / condition (ms)')
#ax.set_title('GPU Jacobian Evaluation Performance for {} mechanism'.format(thedir))
ax.set_xlabel('Number of Reactions')
#ax.legend(loc=0)
plt.savefig('{}_norm.pdf'.format(desc))
plt.close()
return fitvals, retdata
def fullscale_comp(lang, plot_std=True, homedir=None,
cache_opt_default=False,
smem_default=False,
loc_override=None,
text_loc=None, fontsize=10,
color_list=['b', 'g', 'r', 'k']):
if lang == 'c':
langs = ['c', 'tchem']
desc = 'cpu'
smem_default=False
elif lang == 'cuda':
langs = ['cuda']
desc = 'gpu'
else:
raise Exception('unknown lang {}'.format(lang))
def thefilter(x):
return x.cache_opt==cache_opt_default and x.smem == smem_default
fit_vals = []
data = get_data(homedir)
data = [x for x in data if x.lang in langs]
data = filter(thefilter, data)
data = get_fullscale(data)
if not len(data):
print 'no data found... exiting'
sys.exit(-1)
fig, ax = plt.subplots()
miny = None
linestyle = ''
fitvals = []
retdata = []
color_ind = 0
text_ind = None
if text_loc:
text_ind = 0
#FD
plotdata = [x for x in data if x.finite_difference]
if plotdata:
color = color_list[color_ind]
color_ind += 1
miny, they, thez = plot(plotdata, FD_marker, 'Finite Difference', miny, return_y=True, color=color)
theloc = None
if text_ind is not None:
theloc = text_loc[text_ind]
text_ind += 1
fitvals.append(
fit_order(plotdata, they, thez, None, color, text_loc=theloc, fontsize=fontsize)
)
retdata.append(they)
for lang in langs:
plotdata = [x for x in data if not x.finite_difference
and x.lang == lang]
color = color_list[color_ind]
color_ind += 1
if plotdata:
name, marker = nice_names(plotdata[0])
miny, they, thez = plot(plotdata, marker, name, miny, return_y=True, color=color)
theloc = None
if text_ind is not None:
theloc = text_loc[text_ind]
text_ind += 1
fitvals.append(
fit_order(plotdata, they, thez, None, color, text_loc=theloc, fontsize=fontsize)
)
retdata.append(they)
ax.set_yscale('log')
ax.set_ylim(ymin=miny*0.95)
loc = 0 if loc_override is None else loc_override
ax.legend(loc=loc, numpoints=1, fontsize=10)
# add some text for labels, title and axes ticks
ax.set_ylabel('Mean evaluation time / condition (ms)')
#ax.set_title('GPU Jacobian Evaluation Performance for {} mechanism'.format(thedir))
ax.set_xlabel('Number of Reactions')
#ax.legend(loc=0)
plt.savefig('{}_norm.pdf'.format(desc))
plt.close()
return fitvals, retdata
def plotter(data_clean,
plot_name='',
show=True,
plot_reacs=True,
norm=True,
legend_handler=None,
marker_func=None,
minx=None,
miny=None,
maxx=None,
maxy=None,
ylog=False,
return_vals=False,
**filters):
# create fig, ax
plt.figure()
ax = plt.subplot(1, 1, 1)
data = get_filtered_data(data_clean, **filters)
# now plot data
to_plot = ['runtime']
if filters.pop('plot_compilation', False):
to_plot.append('comptime')
if filters.pop('plot_overhead', False):
to_plot.append('overhead')
# get data
plot_data = flatten(data)
# get labels
diffs, diff_locs, diff_check = get_diffs(plot_data)
plot_cores = False
if 'cores' in [diff_check[loc] for loc in diff_locs]:
# can only process one
plot_cores = len(diff_locs) == 1
if plot_cores:
diffs = [sorted(data.keys())]
diff_locs = [-1]
diff_check.append('mechdata.mech')
plot_reacs = False
plot_cores = True
retval = None
# delete diff for vecwidth / par thing
if 'vectype' in [diff_check[loc] for loc in diff_locs]:
ind = next((i for i, loc in enumerate(diff_locs)
if diff_check[loc] == 'vecwidth'), None)
if ind is not None:
diffs.pop(ind)
diff_locs.pop(ind)
if len(diff_locs) > 2:
raise NotImplementedError
if not diff_locs:
# regular plot
for plot in to_plot:
gp.plot(*gp.process_data(plot_data, plot, reacs_as_x=plot_reacs))
else:
# create map dict
loc_map = {}
for i, diff in enumerate(diffs):
for subdiff in diff:
loc_map[subdiff] = diff_locs[i]
# sort
try:
diffs = [sorted(diff, key=lambda x: float(x)) for diff in diffs]
except:
if plot_cores:
# sort by mech size
diffs = [
sorted(diff, key=lambda x: data[x][0].mechdata.n_reactions)
for diff in diffs
]
else:
diffs = [sorted(diff) for diff in diffs]
# first pass - process data
x_vals = []
y_vals = []
z_vals = []
labels = []
def __get_compound_names(val1, val2):
c1 = diff_check[loc_map[val1]]
c2 = diff_check[loc_map[val2]]
# generic name ordering
ordering = ['vectype', 'order']
# sort by order
check_vals = [None for _ in diff_check]
check_vals[loc_map[val1]] = c1
check_vals[loc_map[val2]] = c2
check_vals = sorted(check_vals,
key=lambda x: 100
if x not in ordering else ordering.index(x))
# remove none
check_vals = [x for x in check_vals if x is not None]
# and return str
return ' - '.join(
ps.pretty_names(check).format(val1 if check == c1 else val2)
for check in check_vals)
# handle 2 diffs
if len(diffs) == 1:
for val in [subdiff for diff in diffs for subdiff in diff]:
check = diff_check[loc_map[val]]
match = [
x for x in plot_data
if __compare(x, check, val, plot_cores=plot_cores)
]
if match:
labels.append(ps.pretty_names(check).format(val))
x, y, z = gp.process_data(match,
'runtime',
reacs_as_x=plot_reacs,
plot_cores=plot_cores)
x_vals.append(x)
y_vals.append(y)
z_vals.append(z)
else:
iterator = [
zip(x, diffs[1])
for x in itertools.permutations(diffs[0], len(diffs[0]))
]
iterator = [subiter for i in iterator for subiter in i]
for val1, val2 in iterator:
match = [
x for x in plot_data
if __compare(x,
diff_check[loc_map[val1]],
val1,
plot_cores=plot_cores)
and __compare(x, diff_check[loc_map[val2]], val2)
]
if match:
labels.append(__get_compound_names(val1, val2))
x, y, z = gp.process_data(match,
'runtime',
reacs_as_x=plot_reacs,
plot_cores=plot_cores)
x_vals.append(x)
y_vals.append(y)
z_vals.append(z)
if return_vals:
def __copy_arr(val):
return [v[:] for v in val]
retval = [
__copy_arr(x_vals),
__copy_arr(y_vals),
__copy_arr(z_vals),
copy.copy(labels)
]
# second pass - normalize
if norm and not plot_cores:
xlen = len(next(x for x in x_vals if x))
# find the max y for each x
for ix in range(xlen):
y_max = np.max(
[y_vals[i][ix] for i in range(len(y_vals)) if y_vals[i]])
# divide
for i in range(len(y_vals)):
z_vals[i][ix] = (z_vals[i][ix] /
y_vals[i][ix]) * (y_max / y_vals[i][ix])
y_vals[i][ix] = y_max / y_vals[i][ix]
elif norm:
# parallel scaling eff
for ix in range(len(x_vals)):
for i in range(1, len(x_vals[ix])):
# scaling eff is t1 / (N * tN)
y_vals[ix][i] = y_vals[ix][0] / \
(x_vals[ix][i] * y_vals[ix][i])
# update uncertainty
z_vals[ix][i] = y_vals[ix][i] * np.sqrt(
np.power(z_vals[ix][0] / y_vals[ix][0], 2) +
np.power(z_vals[ix][i] / y_vals[ix][i], 2))
# remove first entry (1 core)
assert x_vals[ix][0] == 1
x_vals[ix] = x_vals[ix][1:]
y_vals[ix] = y_vals[ix][1:]
z_vals[ix] = z_vals[ix][1:]
if ylog:
ax.set_yscale('log')
# and finally plot
for i in range(len(y_vals)):
gp.plot(x_vals[i],
y_vals[i],
z_vals[i],
labels=labels,
plot_ind=i,
marker_func=marker_func)
ax.set_xlim([minx, maxx])
ax.set_ylim([miny, maxy])
ylabel = r'Runtime (\si{\milli\second} / state)'
xlabel = r'Number of {} in Model'.format(
'Species' if not plot_reacs else 'Reactions')
if norm:
ylabel = 'Speedup'
if plot_cores:
ylabel = 'Parallel Scaling Efficiency'
if plot_cores:
xlabel = 'Number of Cores'
plt.ylabel(ylabel)
plt.xlabel(xlabel)
if legend_handler:
plt.legend(*legend_handler, **ps.legend_style).draggable()
else:
plt.legend(**ps.legend_style)
ps.finalize()
if plot_name:
plt.savefig(plot_name)
if show:
plt.show()
return retval
def fullscale_comp(lang, plot_std=True, homedir=None,
cache_opt_default=False,
smem_default=False,
loc_override=None,
text_loc=None,
color_list=['b', 'g', 'r', 'k']
):
if lang == 'c':
langs = ['c', 'tchem']
desc = 'cpu'
smem_default = False
elif lang == 'cuda':
langs = ['cuda']
desc = 'gpu'
else:
raise Exception('unknown lang {}'.format(lang))
def thefilter(x):
return (x.cache_opt==cache_opt_default and
x.smem == smem_default and
x.lang in langs
)
fit_vals = []
data = get_data(homedir)
data = [x for x in data if thefilter(x)]
data = get_fullscale(data)
if not len(data):
print('no data found... exiting')
sys.exit(-1)
fig, ax = plt.subplots()
linestyle = ''
fitvals = []
retdata = []
color_ind = 0
text_ind = None
if text_loc:
text_ind = 0
# finite difference
plotdata = [x for x in data if x.finite_difference]
if plotdata:
color = color_list[color_ind]
color_ind += 1
(minx, miny), y_vals, err_vals = plot(plotdata, FD_marker,
'Finite Difference',
return_y=True, color=color
)
theloc = None
if text_ind is not None:
theloc = text_loc[text_ind]
text_ind += 1
fitvals.append(
fit_order(plotdata, y_vals, err_vals, color=color, text_loc=theloc)
)
retdata.append(y_vals)
for lang in langs:
plotdata = [x for x in data if not x.finite_difference
and x.lang == lang
]
color = color_list[color_ind]
color_ind += 1
if plotdata:
name, marker = nice_names(plotdata[0])
(minx, miny), y_vals, err_vals = plot(plotdata, marker, name,
minx, miny,
return_y=True, color=color
)
theloc = None
if text_ind is not None:
theloc = text_loc[text_ind]
text_ind += 1
fitvals.append(
fit_order(plotdata, y_vals, err_vals, None, color, text_loc=theloc)
)
retdata.append(y_vals)
ax.set_yscale('log')
ax.set_ylim(ymin=miny*0.85)
ax.set_xlim(xmin=0)
loc = 0 if loc_override is None else loc_override
ax.legend(loc=loc, numpoints=1, fontsize=font_size,
shadow=True, fancybox=True
)
# add some text for labels, title and axes ticks
ax.set_ylabel('Mean evaluation time / condition (ms)', fontsize=font_size)
ax.set_xlabel('Number of Reactions', fontsize=font_size)
if homedir is None:
homedir = os.path.join(sys.path[0], '../')
homedir = os.path.realpath(homedir)
d = os.path.join(homedir, 'figures')
pp = PdfPages(os.path.join(d, '{}_performance_comparison.pdf'.format(desc)))
pp.savefig()
pp.close()
plt.close()
return fitvals, retdata
