def test_name_suffix():
''' pdf name suffix. '''
pdfpage, fig = pdf.plot_setup('pdf_name_suffix.pdf', font='default')
try:
sin_plot(fig.gca())
finally:
pdf.plot_teardown(pdfpage)
def test_name_suffix():
''' pdf name suffix. '''
pdfpage, fig = pdf.plot_setup('pdf_name_suffix.pdf', font='default')
try:
sin_plot(fig.gca())
finally:
pdf.plot_teardown(pdfpage)
def test_base():
''' pdf base. '''
pdfpage, fig = pdf.plot_setup('pdf_base', font='default')
try:
sin_plot(fig.gca())
finally:
pdf.plot_teardown(pdfpage)
def test_base():
''' pdf base. '''
pdfpage, fig = pdf.plot_setup('pdf_base', font='default')
try:
sin_plot(fig.gca())
finally:
pdf.plot_teardown(pdfpage)
def test_fontsize_times():
''' pdf fontsize with Times font. '''
pdfpage, fig = pdf.plot_setup('pdf_fontsize_times', fontsize=14)
try:
sin_plot(fig.gca(), remove_text=False)
fig.gca().set_title('My title')
finally:
pdf.plot_teardown(pdfpage)
def test_fontsize():
''' pdf fontsize. '''
pdfpage, fig = pdf.plot_setup('pdf_fontsize', fontsize=14, font='default')
try:
sin_plot(fig.gca(), remove_text=False)
fig.gca().set_title('My title')
finally:
pdf.plot_teardown(pdfpage)
def test_figsize():
''' pdf figsize. '''
pdfpage, fig = pdf.plot_setup('pdf_figsize', figsize=(16, 12),
font='default')
try:
sin_plot(fig.gca())
finally:
pdf.plot_teardown(pdfpage)
def test_fontsize_times():
''' pdf fontsize with Times font. '''
pdfpage, fig = pdf.plot_setup('pdf_fontsize_times', fontsize=14)
try:
sin_plot(fig.gca(), remove_text=False)
fig.gca().set_title('My title')
finally:
pdf.plot_teardown(pdfpage)
def test_fontsize():
''' pdf fontsize. '''
pdfpage, fig = pdf.plot_setup('pdf_fontsize', fontsize=14, font='default')
try:
sin_plot(fig.gca(), remove_text=False)
fig.gca().set_title('My title')
finally:
pdf.plot_teardown(pdfpage)
def test_figsize():
''' pdf figsize. '''
pdfpage, fig = pdf.plot_setup('pdf_figsize', figsize=(16, 12),
font='default')
try:
sin_plot(fig.gca())
finally:
pdf.plot_teardown(pdfpage)
def main():
schemes = ['RP', 'FLOV']
latencies = []
filename = '../results/reconfig/latency.txt'
infile = open(filename)
for l, line in enumerate(infile):
if 'time' in line:
line = line.split()
cycles = [int(cycle) for cycle in line[1:-1]]
elif 'RP' in line:
line = line.split()
latencies.append([float(latency) for latency in line[1:-1]])
elif 'gFLOV' in line:
line = line.split()
latencies.append([float(latency) for latency in line[1:-1]])
# figure generation
plt.rc('font', size=14)
plt.rc('legend', fontsize=14)
colors = ['#f2a900', '#00a9e0']
linestyles = ['-', '-']
markers = ['o', '^']
figname = 'reconfig_overhead.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
for s, scheme in enumerate(schemes):
ax.plot(cycles,
latencies[s],
marker=markers[s],
markersize=9,
markeredgewidth=2,
markeredgecolor=colors[s],
fillstyle='none',
color=colors[s],
linestyle=linestyles[s],
linewidth=2,
label=scheme)
ax.set_ylabel('Packet Latency (Cycles)')
ax.set_xlabel('Timeline (Cycles)')
ax.yaxis.grid(True, linestyle='--', color='black')
hdls, lab = ax.get_legend_handles_labels()
ax.legend(hdls,
lab,
loc='upper center',
bbox_to_anchor=(0.5, 1.2),
ncol=2,
frameon=False)
fig.subplots_adjust(top=0.8, bottom=0.2)
pdf.plot_teardown(pdfpage, fig)
def main():
schemes = [
'baseline', 'rpc', 'rpa', 'nord', 'flov', 'opt_flov'
]
paper_schemes = [
'Baseline', 'RP', 'NoRD', 'FLOV', 'FLOV+'
]
#benchmarks = ['blackscholes', 'bodytrack']
#gmean_xlabels = ['blackscholes', 'bodytrack', 'gmean']
#avg_xlabels = ['blackscholes', 'bodytrack', 'average']
benchmarks = [
'blackscholes', 'bodytrack', 'canneal', 'dedup', 'ferret',
'fluidanimate', 'vips', 'x264'
]
gmean_xlabels = [
'blackscholes', 'bodytrack', 'canneal', 'dedup', 'ferret',
'fluidanimate', 'vips', 'x264', 'gmean'
]
avg_xlabels = [
'blackscholes', 'bodytrack', 'canneal', 'dedup', 'ferret',
'fluidanimate', 'vips', 'x264', 'average'
]
energy_components = ['Static Energy', 'Dynamic Energy']
power_components = ['Static Power', 'Dynamic Power']
runtimes = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
norm_runtimes = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
latency = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
hops = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
flov_hops = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
energy = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
dynamic_energies = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
static_energies = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
energy_breakdown = np.zeros(
(int(len(energy_components)), int(len(schemes) * len(benchmarks))),
dtype=np.float)
norm_energy_breakdown = np.zeros(
(int(len(energy_components)), int(len(schemes) * len(benchmarks))),
dtype=np.float)
power = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
dynamic_powers = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
static_powers = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
power_breakdown = np.zeros(
(int(len(energy_components)), int(len(schemes) * len(benchmarks))),
dtype=np.float)
norm_power_breakdown = np.zeros(
(int(len(energy_components)), int(len(schemes) * len(benchmarks))),
dtype=np.float)
energy_delay_product = np.zeros(
(int(len(schemes)), int(len(benchmarks))), dtype=np.float)
paper_energy_delay_product = np.zeros(
(int(len(paper_schemes)), int(len(benchmarks))), dtype=np.float)
paper_norm_edp = np.zeros(
(int(len(paper_schemes)), int(len(gmean_xlabels))), dtype=np.float)
paper_norm_runtimes = np.zeros(
(int(len(paper_schemes)), int(len(benchmarks))), dtype=np.float)
speedup = np.zeros(
(int(len(paper_schemes)), int(len(gmean_xlabels))), dtype=np.float)
paper_latency = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
paper_hops = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
paper_flov_hops = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
paper_norm_energy_breakdown = np.zeros(
(int(len(paper_schemes) * len(avg_xlabels)),
int(len(energy_components))),
dtype=np.float)
paper_norm_power_breakdown = np.zeros(
(int(len(paper_schemes) * len(avg_xlabels)),
int(len(energy_components))),
dtype=np.float)
paper_norm_static_energy = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
paper_norm_dynamic_energy = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
paper_norm_static_power = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
paper_norm_dynamic_power = np.zeros(
(int(len(paper_schemes)), int(len(avg_xlabels))), dtype=np.float)
average_norm_total_energy = np.zeros(
int(len(paper_schemes)), dtype=np.float)
average_norm_dynamic_energy = np.zeros(
int(len(paper_schemes)), dtype=np.float)
average_norm_static_energy = np.zeros(
int(len(paper_schemes)), dtype=np.float)
average_norm_total_power = np.zeros(
int(len(paper_schemes)), dtype=np.float)
average_norm_dynamic_power = np.zeros(
int(len(paper_schemes)), dtype=np.float)
average_norm_static_power = np.zeros(
int(len(paper_schemes)), dtype=np.float)
if os.path.exists('results_8c.npz'):
results = np.load('results_8c.npz')
# Raw resutls
runtimes = results['runtimes']
norm_runtimes = results['norm_runtimes']
energy = results['energy']
energy_breakdown = results['energy_breakdown']
dynamic_energies = results['dynamic_energies']
static_energies = results['static_energies']
norm_energy_breakdown = results['norm_energy_breakdown']
power = results['power']
power_breakdown = results['power_breakdown']
dynamic_powers = results['dynamic_powers']
static_powers = results['static_powers']
norm_power_breakdown = results['norm_power_breakdown']
energy_delay_product = results['energy_delay_product']
latency = results['latency']
hops = results['hops']
flov_hops = results['flov_hops']
# paper resutls
paper_energy_delay_product = results['paper_energy_delay_product']
paper_norm_edp = results['paper_norm_edp']
paper_norm_runtimes = results['paper_norm_runtimes']
speedup = results['speedup']
paper_norm_energy_breakdown = results['paper_norm_energy_breakdown']
paper_norm_static_energy = results['paper_norm_static_energy']
paper_norm_dynamic_energy = results['paper_norm_dynamic_energy']
paper_norm_power_breakdown = results['paper_norm_power_breakdown']
paper_norm_static_power = results['paper_norm_static_power']
paper_norm_dynamic_power = results['paper_norm_dynamic_power']
paper_latency = results['paper_latency']
paper_hops = results['paper_hops']
paper_flov_hops = results['paper_flov_hops']
# others
average_norm_total_energy = results['average_norm_total_energy']
average_norm_dynamic_energy = results['average_norm_dynamic_energy']
average_norm_static_energy = results['average_norm_static_energy']
average_norm_total_power = results['average_norm_total_power']
average_norm_dynamic_power = results['average_norm_dynamic_power']
average_norm_static_power = results['average_norm_static_power']
average_norm_total_energy_over_rp = results['average_norm_total_energy_over_rp']
average_norm_dynamic_energy_over_rp = results['average_norm_dynamic_energy_over_rp']
average_norm_static_energy_over_rp = results['average_norm_static_energy_over_rp']
average_norm_total_power_over_rp = results['average_norm_total_power_over_rp']
average_norm_dynamic_power_over_rp = results['average_norm_dynamic_power_over_rp']
average_norm_static_power_over_rp = results['average_norm_static_power_over_rp']
average_norm_total_energy_over_nord = results['average_norm_total_energy_over_nord']
average_norm_dynamic_energy_over_nord = results['average_norm_dynamic_energy_over_nord']
average_norm_static_energy_over_nord = results['average_norm_static_energy_over_nord']
average_norm_total_power_over_nord = results['average_norm_total_power_over_nord']
average_norm_dynamic_power_over_nord = results['average_norm_dynamic_power_over_nord']
average_norm_static_power_over_nord = results['average_norm_static_power_over_nord']
else:
router_config_file = "ext/dsent/configs/booksim_router.cfg"
link_config_file = "ext/dsent/configs/booksim_link.cfg"
for s, scheme in enumerate(schemes):
for b, benchmark in enumerate(benchmarks):
# runtime
filename = 'm5out-8c-4x4mesh/restore_' + scheme + '/' + benchmark + '8_4x4mesh_simsmall/stats.txt'
statsfile = open(filename)
for l, line in enumerate(statsfile):
if 'sim_seconds' in line:
line = line.split()
runtime = float(line[1])
runtimes[s][b] = runtime
break
norm_runtimes[s][b] = runtimes[s][b] / runtimes[0][b]
# energy
sim_directory = "m5out-8c-4x4mesh/restore_" + scheme + "/" + benchmark + "8_4x4mesh_simsmall"
dynamic_power, static_power, dynamic_energy, static_energy = power_model.getPowerAndEnergy(
sim_directory, router_config_file, link_config_file)
if static_energy < 0:
print('Negative power: {}'.format(sim_directory))
energy[s][b] = dynamic_energy + static_energy
dynamic_energies[s][b] = dynamic_energy
static_energies[s][b] = static_energy
energy_breakdown[0][b * len(schemes) + s] = static_energy
energy_breakdown[1][b * len(schemes) + s] = dynamic_energy
baseline_total_energy = energy_breakdown[0][b * len(
schemes)] + energy_breakdown[1][b * len(schemes)]
norm_energy_breakdown[0][
b * len(schemes) + s] = static_energy / baseline_total_energy
norm_energy_breakdown[1][
b * len(schemes) + s] = dynamic_energy / baseline_total_energy
power[s][b] = dynamic_power + static_power
dynamic_powers[s][b] = dynamic_power
static_powers[s][b] = static_power
power_breakdown[0][b * len(schemes) + s] = static_power
power_breakdown[1][b * len(schemes) + s] = dynamic_power
baseline_total_power = power_breakdown[0][b * len(
schemes)] + power_breakdown[1][b * len(schemes)]
norm_power_breakdown[0][
b * len(schemes) + s] = static_power / baseline_total_power
norm_power_breakdown[1][
b * len(schemes) + s] = dynamic_power / baseline_total_power
# latency and hop count
booksim_stats_file = 'm5out-8c-4x4mesh/restore_{}/{}8_4x4mesh_simsmall/booksimstats.json'.format(scheme, benchmark)
with open(booksim_stats_file) as jsonfile:
booksim_stats = json.load(jsonfile)
latency[s][b] = booksim_stats['packet-latency']['average']
hops[s][b] = booksim_stats['hops-average']
if scheme == 'flov' or scheme == 'opt_flov':
flov_hops[s][b] = booksim_stats['flov-hops-average']
energy_delay_product = energy * runtimes
paper_norm_runtimes[[0, 1], :] = norm_runtimes[[0, 1], :]
paper_norm_runtimes[2:, :] = norm_runtimes[3:, :]
paper_energy_delay_product[[0, 1], :] = energy_delay_product[[0, 1], :]
paper_energy_delay_product[2:, :] = energy_delay_product[3:, :]
paper_latency[[0, 1], :-1] = latency[[0, 1], :]
paper_latency[2:, :-1] = latency[3:, :]
paper_hops[[0, 1], :-1] = hops[[0, 1], :]
paper_hops[2:, :-1] = hops[3:, :]
paper_flov_hops[[0, 1], :-1] = flov_hops[[0, 1], :]
paper_flov_hops[2:, :-1] = flov_hops[3:, :]
del_cols = []
for b, benchmark in enumerate(benchmarks):
if energy_delay_product[1][b] > energy_delay_product[2][b]:
paper_norm_runtimes[1][b] = norm_runtimes[2][b]
paper_energy_delay_product[1][b] = energy_delay_product[2][b]
paper_latency[1][b] = latency[2][b]
paper_hops[1][b] = hops[2][b]
paper_flov_hops[1][b] = flov_hops[2][b]
del_cols.append(b * len(schemes) + 1)
else:
del_cols.append(b * len(schemes) + 2)
# speedup
for s, scheme in enumerate(paper_schemes):
speedup[s, 0:-1] = 1 / paper_norm_runtimes[s, :]
speedup[s][-1] = stats.mstats.gmean(speedup[s][0:-1])
# energy-delay product
for s, scheme in enumerate(paper_schemes):
for b, benchmark in enumerate(benchmarks):
paper_norm_edp[s][b] = paper_energy_delay_product[s][b] / paper_energy_delay_product[0][b]
paper_norm_edp[s][-1] = stats.mstats.gmean(paper_norm_edp[s][0:-1])
# latency and hops
for s, scheme in enumerate(paper_schemes):
paper_latency[s][-1] = np.mean(paper_latency[s][0:-1])
paper_hops[s][-1] = np.mean(paper_hops[s][0:-1])
paper_flov_hops[s][-1] = np.mean(paper_flov_hops[s][0:-1])
# energy
data = [list(i) for i in zip(*norm_energy_breakdown)]
data = np.array(data, dtype=np.float)
data = np.transpose(data)
data = np.delete(data, del_cols, 1)
paper_norm_energy_breakdown[:-len(paper_schemes), :] = np.transpose(data)
paper_static_energy = np.zeros(
(int(len(paper_schemes)), int(len(benchmarks))), dtype=np.float)
paper_dynamic_energy = np.zeros(
(int(len(paper_schemes)), int(len(benchmarks))), dtype=np.float)
for s, scheme in enumerate(paper_schemes):
for e, energy_compoent in enumerate(energy_components):
energy = [
paper_norm_energy_breakdown[b * len(paper_schemes) + s][e]
for b in range(len(benchmarks))
]
mean_energy = np.mean(energy)
paper_norm_energy_breakdown[len(benchmarks) * len(paper_schemes)
+ s][e] = mean_energy
average_norm_total_energy[s] += mean_energy
average_norm_static_energy[s] = paper_norm_energy_breakdown[
len(benchmarks) * len(paper_schemes) + s][0]
average_norm_dynamic_energy[s] = paper_norm_energy_breakdown[
len(benchmarks) * len(paper_schemes) + s][1]
for b, benchmark in enumerate(benchmarks):
paper_static_energy[s][b] = paper_norm_energy_breakdown[b * len(paper_schemes) + s][0]
paper_dynamic_energy[s][b] = paper_norm_energy_breakdown[b * len(paper_schemes) + s][1]
paper_norm_static_energy[s][b] = paper_static_energy[s][b] / paper_static_energy[0][b]
paper_norm_dynamic_energy[s][b] = paper_dynamic_energy[s][b] / paper_dynamic_energy[0][b]
paper_norm_static_energy[s][-1] = stats.mstats.gmean(paper_norm_static_energy[s][0:-1])
paper_norm_dynamic_energy[s][-1] = stats.mstats.gmean(paper_norm_dynamic_energy[s][0:-1])
average_norm_static_energy = average_norm_static_energy / average_norm_static_energy[
0]
average_norm_dynamic_energy = average_norm_dynamic_energy / average_norm_dynamic_energy[
0]
average_norm_total_energy_over_rp = average_norm_total_energy[
1:] / average_norm_total_energy[1]
average_norm_static_energy_over_rp = average_norm_static_energy[
1:] / average_norm_static_energy[1]
average_norm_dynamic_energy_over_rp = average_norm_dynamic_energy[
1:] / average_norm_dynamic_energy[1]
average_norm_total_energy_over_nord = average_norm_total_energy[
2:] / average_norm_total_energy[2]
average_norm_static_energy_over_nord = average_norm_static_energy[
2:] / average_norm_static_energy[2]
average_norm_dynamic_energy_over_nord = average_norm_dynamic_energy[
2:] / average_norm_dynamic_energy[2]
# power
data = [list(i) for i in zip(*norm_power_breakdown)]
data = np.array(data, dtype=np.float)
data = np.transpose(data)
data = np.delete(data, del_cols, 1)
paper_norm_power_breakdown[:-len(paper_schemes), :] = np.transpose(data)
paper_static_power = np.zeros(
(int(len(paper_schemes)), int(len(benchmarks))), dtype=np.float)
paper_dynamic_power = np.zeros(
(int(len(paper_schemes)), int(len(benchmarks))), dtype=np.float)
for s, scheme in enumerate(paper_schemes):
for p, component in enumerate(power_components):
power = [
paper_norm_power_breakdown[b * len(paper_schemes) + s][p]
for b in range(len(benchmarks))
]
mean_power = np.mean(power)
paper_norm_power_breakdown[len(benchmarks) * len(paper_schemes)
+ s][p] = mean_power
average_norm_total_power[s] += mean_power
average_norm_static_power[s] = paper_norm_power_breakdown[
len(benchmarks) * len(paper_schemes) + s][0]
average_norm_dynamic_power[s] = paper_norm_power_breakdown[
len(benchmarks) * len(paper_schemes) + s][1]
for b, benchmark in enumerate(benchmarks):
paper_static_power[s][b] = paper_norm_power_breakdown[b * len(paper_schemes) + s][0]
paper_dynamic_power[s][b] = paper_norm_power_breakdown[b * len(paper_schemes) + s][1]
paper_norm_static_power[s][b] = paper_static_power[s][b] / paper_static_power[0][b]
paper_norm_dynamic_power[s][b] = paper_dynamic_power[s][b] / paper_dynamic_power[0][b]
paper_norm_static_power[s][-1] = stats.mstats.gmean(paper_norm_static_power[s][0:-1])
paper_norm_dynamic_power[s][-1] = stats.mstats.gmean(paper_norm_dynamic_power[s][0:-1])
average_norm_static_power = average_norm_static_power / average_norm_static_power[
0]
average_norm_dynamic_power = average_norm_dynamic_power / average_norm_dynamic_power[
0]
average_norm_total_power_over_rp = average_norm_total_power[
1:] / average_norm_total_power[1]
average_norm_static_power_over_rp = average_norm_static_power[
1:] / average_norm_static_power[1]
average_norm_dynamic_power_over_rp = average_norm_dynamic_power[
1:] / average_norm_dynamic_power[1]
average_norm_total_power_over_nord = average_norm_total_power[
2:] / average_norm_total_power[2]
average_norm_static_power_over_nord = average_norm_static_power[
2:] / average_norm_static_power[2]
average_norm_dynamic_power_over_nord = average_norm_dynamic_power[
2:] / average_norm_dynamic_power[2]
np.savez('results_8c.npz',
# raw data
runtimes=runtimes, norm_runtimes=norm_runtimes,
energy=energy, energy_breakdown=energy_breakdown,
dynamic_energies=dynamic_energies,
static_energies=static_energies,
norm_energy_breakdown=norm_energy_breakdown,
power=power, power_breakdown=power_breakdown,
dynamic_powers=dynamic_powers,
static_powers=static_powers,
norm_power_breakdown=norm_power_breakdown,
energy_delay_product=energy_delay_product,
paper_energy_delay_product=paper_energy_delay_product,
paper_norm_edp=paper_norm_edp,
latency=latency,
hops=hops,
flov_hops=flov_hops,
# paper results
paper_norm_runtimes=paper_norm_runtimes, speedup=speedup,
paper_norm_energy_breakdown=paper_norm_energy_breakdown,
paper_norm_static_energy=paper_norm_static_energy,
paper_norm_dynamic_energy=paper_norm_dynamic_energy,
paper_norm_power_breakdown=paper_norm_power_breakdown,
paper_norm_static_power=paper_norm_static_power,
paper_norm_dynamic_power=paper_norm_dynamic_power,
paper_latency=paper_latency,
paper_hops=paper_hops,
paper_flov_hops=paper_flov_hops,
# over baseline
average_norm_total_energy=average_norm_total_energy,
average_norm_dynamic_energy=average_norm_dynamic_energy,
average_norm_static_energy=average_norm_static_energy,
average_norm_total_power=average_norm_total_power,
average_norm_dynamic_power=average_norm_dynamic_power,
average_norm_static_power=average_norm_static_power,
# over RP
average_norm_total_energy_over_rp=average_norm_total_energy_over_rp,
average_norm_dynamic_energy_over_rp=average_norm_dynamic_energy_over_rp,
average_norm_static_energy_over_rp=average_norm_static_energy_over_rp,
average_norm_total_power_over_rp=average_norm_total_power_over_rp,
average_norm_dynamic_power_over_rp=average_norm_dynamic_power_over_rp,
average_norm_static_power_over_rp=average_norm_static_power_over_rp,
# over nord
average_norm_total_energy_over_nord=average_norm_total_energy_over_nord,
average_norm_dynamic_energy_over_nord=average_norm_dynamic_energy_over_nord,
average_norm_static_energy_over_nord=average_norm_static_energy_over_nord,
average_norm_total_power_over_nord=average_norm_total_power_over_nord,
average_norm_dynamic_power_over_nord=average_norm_dynamic_power_over_nord,
average_norm_static_power_over_nord=average_norm_static_power_over_nord)
print("runtime speedup over Baseline: ", speedup[:, -1])
print("runtime speedup over RP: ", (speedup[1:,-1] / speedup[1][-1]))
print("runtime speedup over NoRD: ", (speedup[2:,-1] / speedup[2][-1]))
print("average normalized total energy over Baseline: ",
average_norm_total_energy)
print("average normalized dynamic energy over Baseline: ",
average_norm_dynamic_energy)
print("average normalized static energy over Baseline: ",
average_norm_static_energy)
print("average normalized total power over Baseline: ",
average_norm_total_power)
print("average normalized dynamic power over Baseline: ",
average_norm_dynamic_power)
print("average normalized static power over Baseline: ",
average_norm_static_power)
print("average normalized total energy over RP: ",
average_norm_total_energy_over_rp)
print("average normalized dynamic energy over RP: ",
average_norm_dynamic_energy_over_rp)
print("average normalized static energy over RP: ",
average_norm_static_energy_over_rp)
print("average normalized total power over RP: ",
average_norm_total_power_over_rp)
print("average normalized dynamic poewr over RP: ",
average_norm_dynamic_power_over_rp)
print("average normalized static power over RP: ",
average_norm_static_power_over_rp)
print("average normalized total energy over NoRD: ",
average_norm_total_energy_over_nord)
print("average normalized dynamic energy over NoRD: ",
average_norm_dynamic_energy_over_nord)
print("average normalized static energy over NoRD: ",
average_norm_static_energy_over_nord)
print("average normalized total power over NoRD: ",
average_norm_total_power_over_nord)
print("average normalized dynamic poewr over NoRD: ",
average_norm_dynamic_power_over_nord)
print("average normalized static power over NoRD: ",
average_norm_static_power_over_nord)
# write to a file
with open('results_8c.csv', mode='w') as result_file:
# write runtime
result_file.write('Raw runtime\n')
for s, scheme in enumerate(schemes):
result_file.write(',{}'.format(scheme))
result_file.write('\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(schemes):
result_file.write(',{}'.format(runtimes[s][b]))
result_file.write('\n')
result_file.write('\n')
# write normalized runtime
result_file.write('Normalized runtime\n')
for s, scheme in enumerate(paper_schemes):
result_file.write(',{}'.format(scheme))
result_file.write('\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(paper_schemes):
result_file.write(',{}'.format(paper_norm_runtimes[s][b]))
result_file.write('\n')
result_file.write('\n')
# write speedup
result_file.write('Speedup\n')
for s, scheme in enumerate(paper_schemes):
result_file.write(',{}'.format(scheme))
result_file.write('\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(paper_schemes):
result_file.write(',{}'.format(speedup[s][b]))
result_file.write('\n')
result_file.write('\n')
# write energy
result_file.write('Raw energy\n')
result_file.write(',,Static Energy,Dynamic Energy\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(schemes):
result_file.write(',{},{},{}\n'.format(scheme,
energy_breakdown[0][b * len(schemes) + s],
energy_breakdown[1][b * len(schemes) + s]))
result_file.write('\n')
# write nromalized energy
result_file.write('Normalized energy\n')
result_file.write(',,Static Energy,Dynamic Energy\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(paper_schemes):
result_file.write(',{},{},{}\n'.format(scheme,
paper_norm_energy_breakdown[b * len(paper_schemes) + s][0],
paper_norm_energy_breakdown[b * len(paper_schemes) + s][1]))
result_file.write('\n')
# write power
result_file.write('Raw power\n')
result_file.write(',,Static Power,Dynamic Power\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(schemes):
result_file.write(',{},{},{}\n'.format(scheme,
static_powers[s][b], dynamic_powers[s][b]))
#power_breakdown[0][b * len(schemes) + s],
#power_breakdown[1][b * len(schemes) + s]))
result_file.write('\n')
# write nromalized power
result_file.write('Normalized power\n')
result_file.write(',,Static Power,Dynamic Power\n')
for b, benchmark in enumerate(benchmarks):
result_file.write(benchmark)
for s, scheme in enumerate(paper_schemes):
result_file.write(',{},{},{}\n'.format(scheme,
paper_norm_power_breakdown[b * len(paper_schemes) + s][0],
paper_norm_power_breakdown[b * len(paper_schemes) + s][1]))
result_file.write('\n')
result_file.close()
plt.rc('legend', fontsize=12)
# runtime speedup
colors = ['#f1eef6', '#d0d1e6', '#a6bddb', '#74a9cf', '#2b8cbe', '#045a8d']
colors = ['#eff3ff','#bdd7e7','#6baed6','#3182bd','#08519c']
data = [list(i) for i in zip(*speedup)]
figname = 'parsec_speedup.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
hdls = barchart.draw(
ax,
data,
group_names=gmean_xlabels,
entry_names=paper_schemes,
colors=colors,
breakdown=False,
legendloc='upper center',
legendncol=len(paper_schemes))
fig.autofmt_xdate()
ax.yaxis.grid(True, linestyle='--')
ax.set_ylabel('Runtime Speedup')
#ax.set_xlabel('Benchmarks')
ax.legend(
hdls,
paper_schemes,
loc='upper center',
bbox_to_anchor=(0.5, 1.18),
ncol=len(paper_schemes),
frameon=False,
handletextpad=0.5,
columnspacing=1)
fmt.resize_ax_box(ax, hratio=0.8)
pdf.plot_teardown(pdfpage, fig)
# latency
data = [list(i) for i in zip(*paper_latency)]
figname = 'parsec_latency.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
hdls = barchart.draw(
ax,
data,
group_names=gmean_xlabels,
entry_names=paper_schemes,
colors=colors,
breakdown=False,
legendloc='upper center',
legendncol=len(paper_schemes))
fig.autofmt_xdate()
ax.yaxis.grid(True, linestyle='--')
ax.set_ylabel('Average Packet Latency (cycles)')
#ax.set_xlabel('Benchmarks')
ax.legend(
hdls,
paper_schemes,
loc='upper center',
bbox_to_anchor=(0.5, 1.18),
ncol=len(paper_schemes),
frameon=False,
handletextpad=0.1,
columnspacing=0.5)
fmt.resize_ax_box(ax, hratio=0.8)
pdf.plot_teardown(pdfpage, fig)
# hops
data = paper_hops + paper_flov_hops
data = [list(i) for i in zip(*data)]
figname = 'parsec_hops.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
hdls = barchart.draw(
ax,
data,
group_names=gmean_xlabels,
entry_names=paper_schemes,
colors=colors,
breakdown=False,
legendloc='upper center',
legendncol=len(paper_schemes))
fig.autofmt_xdate()
ax.yaxis.grid(True, linestyle='--')
ax.set_ylabel('Average Packet Hops')
#ax.set_xlabel('Benchmarks')
ax.legend(
hdls,
paper_schemes,
loc='upper center',
bbox_to_anchor=(0.5, 1.18),
ncol=len(paper_schemes),
frameon=False,
handletextpad=0.1,
columnspacing=0.5)
fmt.resize_ax_box(ax, hratio=0.8)
pdf.plot_teardown(pdfpage, fig)
# energy-delay product
data = [list(i) for i in zip(*paper_norm_edp)]
figname = 'parsec_edp.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
hdls = barchart.draw(
ax,
data,
group_names=gmean_xlabels,
entry_names=paper_schemes,
colors=colors,
breakdown=False,
legendloc='upper center',
legendncol=len(paper_schemes))
fig.autofmt_xdate()
ax.yaxis.grid(True, linestyle='--')
ax.set_ylabel('Normalized Energy-Delay Product')
#ax.set_xlabel('Benchmarks')
ax.legend(
hdls,
paper_schemes,
loc='upper center',
bbox_to_anchor=(0.5, 1.18),
ncol=len(paper_schemes),
frameon=False,
handletextpad=0.1,
columnspacing=0.5)
fmt.resize_ax_box(ax, hratio=0.8)
pdf.plot_teardown(pdfpage, fig)
# energy
group_names = []
xticks = []
for b, benchmark in enumerate(avg_xlabels):
for s, scheme in enumerate(paper_schemes):
group_names.append(scheme)
xticks.append(b * (len(paper_schemes) + 1) + s)
#colors = ['#0570b0', '#fee0d2']
colors = ['#a63603','#fee6ce']
figname = "parsec_energy_breakdown.pdf"
pdfpage, fig = pdf.plot_setup(figname, figsize=(10, 4), fontsize=10)
ax = fig.gca()
ax2 = ax.twinx() # for normalized static energy, must put it here for the look
hdls = barchart.draw(
ax,
paper_norm_energy_breakdown,
group_names=group_names,
entry_names=energy_components,
breakdown=True,
xticks=xticks,
colors=colors,
legendloc='upper center',
legendncol=2,
xticklabelfontsize=11,
xticklabelrotation=90)
ax.set_ylabel('Normalized Energy')
#ax.set_xlabel('Benchmarks')
ax.xaxis.set_label_coords(0.5, -0.55)
ax.yaxis.grid(True, linestyle='--')
ax.set_ylim([0, 2.5])
fmt.resize_ax_box(ax, hratio=0.8)
ly = len(avg_xlabels)
scale = 1. / ly
ypos = -.5
pos = 0
for pos in xrange(ly + 1):
lxpos = (pos + 0.5) * scale
if pos < ly:
ax.text(
lxpos,
ypos,
avg_xlabels[pos],
ha='center',
transform=ax.transAxes,
fontsize=12)
add_line(ax, pos * scale, ypos)
add_line(ax, 1, ypos)
# add static energy at secondary axis
xs = []
p = 0.0
for g in range(len(avg_xlabels)):
xs.append([])
for pos in range(len(paper_schemes)):
xs[g].append(p)
p = p + 1
p = p + 1
data = [list(i) for i in zip(*paper_norm_static_energy)]
data = np.array(data, dtype=np.float64)
ax2.set_ylabel('Normalized Static Energy')
ax2.set_ylim(0, 1.5)
for i in range(len(avg_xlabels)):
tmp = ax2.plot(xs[i],
data[i],
'-o',
markersize=6,
color='#004b87',
markeredgecolor='#004b87')
if i == 0:
hdls += tmp
ax.legend(
hdls,
energy_components + ['Normalized Static Energy'],
loc='upper center',
bbox_to_anchor=(0.5, 1.2),
ncol=len(energy_components) + 1,
frameon=False,
handletextpad=1,
columnspacing=2)
fig.subplots_adjust(bottom=0.38)
pdf.plot_teardown(pdfpage, fig)
figname = "parsec_power_breakdown.pdf"
pdfpage, fig = pdf.plot_setup(figname, figsize=(10, 4), fontsize=14)
ax = fig.gca()
ax2 = ax.twinx() # for normalized static power, must put it here for the look
hdls = barchart.draw(
ax,
paper_norm_power_breakdown,
group_names=group_names,
entry_names=energy_components,
breakdown=True,
xticks=xticks,
colors=colors,
legendloc='upper center',
legendncol=2,
xticklabelfontsize=11,
xticklabelrotation=90)
ax.set_ylabel('Normalized Power')
#ax.set_xlabel('Benchmarks')
ax.xaxis.set_label_coords(0.5, -0.55)
ax.yaxis.grid(True, linestyle='--')
ax.set_ylim([0, 1.2])
fmt.resize_ax_box(ax, hratio=0.8)
ly = len(avg_xlabels)
scale = 1. / ly
ypos = -.5
pos = 0
for pos in xrange(ly + 1):
lxpos = (pos + 0.5) * scale
if pos < ly:
ax.text(
lxpos,
ypos,
avg_xlabels[pos],
ha='center',
transform=ax.transAxes,
fontsize=12)
add_line(ax, pos * scale, ypos)
add_line(ax, 1, ypos)
# add static power at secondary axis
xs = []
p = 0.0
for g in range(len(avg_xlabels)):
xs.append([])
for pos in range(len(paper_schemes)):
xs[g].append(p)
p = p + 1
p = p + 1
data = [list(i) for i in zip(*paper_norm_static_power)]
data = np.array(data, dtype=np.float64)
ax2.set_ylabel('Normalized Static Power')
ax2.set_ylim(0, 1.2)
for i in range(len(avg_xlabels)):
tmp = ax2.plot(xs[i],
data[i],
'-o',
markersize=6,
color='#004b87',
markeredgecolor='#004b87')
if i == 0:
hdls += tmp
ax.legend(
hdls,
power_components + ['Normalized Static Power'],
loc='upper center',
bbox_to_anchor=(0.5, 1.2),
ncol=len(power_components) + 1,
frameon=False,
handletextpad=1,
columnspacing=2)
fig.subplots_adjust(bottom=0.38)
pdf.plot_teardown(pdfpage, fig)
def main():
traffic = sys.argv[1]
injection_rate = sys.argv[2]
injection_rate_name = {'0.02': '002', '0.08': '008'}
schemes = [
'baseline', 'rpa', 'rpc', 'nord', 'flov', 'opt_flov'
]
paper_schemes = [
'Baseline', 'RP', 'NoRD', 'FLOV', 'FLOV+'
]
off_percentile = [10, 20, 30, 40, 50, 60, 70, 80]
breakdown_comp = [
'router latency', 'FLOV latency', 'link latency',
'serialization latency', 'contention latency'
]
breakdown_comp = [
'router', 'FLOV', 'link',
'serialization', 'contention'
]
power_breakdown_comp = ['dynamic', 'static']
latency = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
static_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
dynamic_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
total_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
flit_lat = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
hops = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
flov_hops = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
latency_breakdown = np.zeros(
(len(breakdown_comp), int(len(off_percentile) * len(schemes))),
dtype=np.float)
power_breakdown = np.zeros(
(len(power_breakdown_comp), int(len(off_percentile) * len(schemes))),
dtype=np.float)
router_static_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
router_dynamic_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
router_total_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
paper_latency = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
paper_static_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
paper_dynamic_power = np.zeros(
(int(len(schemes)), int(len(off_percentile))), dtype=np.float)
paper_latency_breakdown = np.zeros(
(len(breakdown_comp), int(len(off_percentile) * len(paper_schemes))),
dtype=np.float)
power_power_breakdown = np.zeros(
(len(power_breakdown_comp), int(len(off_percentile) * len(paper_schemes))),
dtype=np.float)
for s, scheme in enumerate(schemes):
for o, off in enumerate(off_percentile):
filename = scheme + '/' + traffic + '_' + injection_rate + 'inj_' + str(
off) + 'off.log'
infile = open(filename)
is_router = False
for l, line in enumerate(infile):
if 'Packet latency average' in line and 'samples' in line:
line = line.split()
latency[s][o] = line[4]
elif 'Flit latency average' in line and 'samples' in line:
line = line.split()
flit_lat[s][o] = line[4]
elif 'Hops average' in line and 'samples' in line:
line = line.split()
hops[s][o] = line[3]
elif 'FLOV hops' in line and 'samples' in line:
line = line.split()
flov_hops[s][o] = line[4]
elif 'Total Dynamic Power' in line and is_router == False:
line = line.split()
dynamic_power[s][o] = line[4]
power_breakdown[0][o * len(schemes) + s] = line[4]
elif 'Total Leakage Power' in line and is_router == False:
line = line.split()
static_power[s][o] = line[4]
power_breakdown[1][o * len(schemes) + s] = line[4]
elif 'Total Power:' in line and is_router == False:
is_router = True
line = line.split()
total_power[s][o] = line[3]
elif 'Total Dynamic Power' in line and is_router == True:
line = line.split()
router_dynamic_power[s][o] = line[4]
elif 'Total Leakage Power' in line and is_router == True:
line = line.split()
router_static_power[s][o] = line[4]
elif 'Total Power:' in line and is_router == True:
line = line.split()
router_total_power[s][o] = line[3]
zeroload_lat = 0
latency_breakdown[0][o * len(schemes)
+ s] = hops[s][o] * 3 # router_lat
zeroload_lat += latency_breakdown[0][o * len(schemes) + s]
latency_breakdown[1][o * len(schemes)
+ s] = flov_hops[s][o] # flov_lat
zeroload_lat += latency_breakdown[1][o * len(schemes) + s]
latency_breakdown[
2][o * len(schemes)
+ s] = flov_hops[s][o] + hops[s][o] + 1 # link_lat
zeroload_lat += latency_breakdown[2][o * len(schemes) + s]
latency_breakdown[3][o * len(schemes) + s] = 4 # serilized_lat
zeroload_lat += latency_breakdown[3][o * len(schemes) + s]
latency_breakdown[
4][o * len(schemes)
+ s] = latency[s][o] - zeroload_lat # contention
paper_latency = latency[[0, 1, 3, 4, 5], :]
paper_dynamic_power = dynamic_power[[0, 1, 3, 4, 5], :]
paper_static_power = static_power[[0, 1, 3, 4, 5], :]
paper_total_power = total_power[[0, 1, 3, 4, 5], :]
# select aggresive or conservative for router parking
del_cols = []
for o, off in enumerate(off_percentile):
if total_power[1][o] > total_power[2][o]:
paper_latency[1][o] = latency[2][o]
paper_dynamic_power[1][o] = dynamic_power[2][o]
paper_static_power[1][o] = static_power[2][o]
paper_total_power[1][o] = total_power[2][o]
del_cols.append(o * len(schemes) + 1)
else:
del_cols.append(o * len(schemes) + 2)
#print latency
#print paper_latency
#print static_power
data = [list(i) for i in zip(*latency_breakdown)]
data = np.array(data, dtype=np.float)
data = np.transpose(data)
data = np.delete(data, del_cols, 1)
paper_latency_breakdown = np.transpose(data)
data = [list(i) for i in zip(*power_breakdown)]
data = np.array(data, dtype=np.float)
data = np.transpose(data)
data = np.delete(data, del_cols, 1)
paper_power_breakdown = np.transpose(data)
# figure generation
plt.rc('font', size=14)
plt.rc('legend', fontsize=14)
# matlab colors
colors = ['#b7312c', '#f2a900', '#00a9e0', '#004b87', '#715091', '#636569',
'#0076a8', '#d78825']
markers = ['x', 'o', '^', 's', 'p', 'v', 'D', 'x']
linestyles = ['-', '-', '-', '-', '-']
figname = traffic + injection_rate_name[injection_rate] + 'latency.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
for s, scheme in enumerate(paper_schemes):
ax.plot(
off_percentile,
paper_latency[s, :],
marker=markers[s],
markersize=9,
markeredgewidth=2,
fillstyle='none',
markeredgecolor=colors[s],
color=colors[s],
linestyle=linestyles[s],
linewidth=2,
label=scheme)
ax.set_ylabel('Packet Latency (Cycles)')
#ax.set_xlabel('Fraction of Power-Gated Cores (%)')
xlab = 'Fraction of Power-Gated Cores (%), ' + injection_rate + ' flits/core/cycle'
ax.set_xlabel(xlab)
ax.yaxis.grid(True, linestyle='--', color='black')
hdls, lab = ax.get_legend_handles_labels()
ax.legend(
hdls,
lab,
loc='upper center',
bbox_to_anchor=(0.5, 1.2),
ncol=len(paper_schemes),
frameon=False)
ax.set_xlim(0, 90)
fig.subplots_adjust(top=0.85, bottom=0.2)
pdf.plot_teardown(pdfpage, fig)
group_names = []
xticks = []
for o, off in enumerate(off_percentile):
for s, scheme in enumerate(paper_schemes):
group_names.append(scheme)
xticks.append(o * (len(paper_schemes) + 1) + s)
# normalized power breakdown
colors = ['#a63603','#fee6ce']
figname = traffic + injection_rate_name[injection_rate] + 'power_breakdown.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
ax2 = ax.twinx() # for normalized static power, must put it here for the look
hdls = barchart.draw(
ax,
paper_power_breakdown,
group_names=group_names,
entry_names=power_breakdown_comp,
breakdown=True,
xticks=xticks,
width=0.8,
colors=colors,
legendloc='upper center',
legendncol=5,
xticklabelfontsize=11,
xticklabelrotation=90)
ax.set_ylabel('Power (Watts)')
ax.set_xlabel(xlab)
ax.xaxis.set_label_coords(0.5, -0.55)
ax.yaxis.grid(True, linestyle='--')
fmt.resize_ax_box(ax, hratio=0.8)
ly = len(off_percentile)
scale = 1. / ly
ypos = -.5
pos = 0
for pos in xrange(ly + 1):
lxpos = (pos + 0.5) * scale
if pos < ly:
ax.text(
lxpos,
ypos,
off_percentile[pos],
ha='center',
transform=ax.transAxes)
add_line(ax, pos * scale, ypos)
add_line(ax, 1, ypos)
# add static power at secondary axis
xs = []
p = 0.0
for g in range(len(off_percentile)):
xs.append([])
for pos in range(len(paper_schemes)):
xs[g].append(p)
p = p + 1
p = p + 1
data = [list(i) for i in zip(*paper_static_power)]
data = np.array(data, dtype=np.float64)
ax2.set_ylabel('Static Power (Watts)')
ax2.set_ylim(0, 0.6)
for i in range(len(off_percentile)):
tmp = ax2.plot(xs[i],
data[i],
'-o',
markersize=6,
color='#004b87',
markeredgecolor='#004b87')
if i == 0:
hdls += tmp
ax.legend(
hdls,
power_breakdown_comp + ['static power'],
loc='upper center',
bbox_to_anchor=(0.5, 1.2),
ncol=len(power_breakdown_comp) + 1,
frameon=False,
handletextpad=1,
columnspacing=2)
fig.subplots_adjust(bottom=0.38)
pdf.plot_teardown(pdfpage, fig)
# latency breakdown
colors = ['#08519c','#bdd7e7','#6baed6','#3182bd','#eff3ff']
figname = traffic + injection_rate_name[injection_rate] + 'lat_breakdown.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 4), fontsize=14)
ax = fig.gca()
hdls = barchart.draw(
ax,
paper_latency_breakdown,
group_names=group_names,
entry_names=breakdown_comp,
breakdown=True,
xticks=xticks,
width=0.8,
colors=colors,
legendloc='upper center',
legendncol=5,
xticklabelfontsize=11,
xticklabelrotation=90)
ax.set_ylabel('Latency (Cycles)')
ax.set_xlabel(xlab)
ax.xaxis.set_label_coords(0.5, -0.55)
ax.yaxis.grid(True, linestyle='--')
ax.legend(
hdls,
breakdown_comp,
loc='upper center',
bbox_to_anchor=(0.5, 1.2),
ncol=5,
frameon=False,
handletextpad=0.1,
columnspacing=0.5)
fmt.resize_ax_box(ax, hratio=0.8)
ly = len(off_percentile)
scale = 1. / ly
ypos = -.5
pos = 0
for pos in xrange(ly + 1):
lxpos = (pos + 0.5) * scale
if pos < ly:
ax.text(
lxpos,
ypos,
off_percentile[pos],
ha='center',
transform=ax.transAxes)
add_line(ax, pos * scale, ypos)
add_line(ax, 1, ypos)
fig.subplots_adjust(bottom=0.38)
pdf.plot_teardown(pdfpage, fig)
plt.show()
def main():
traffic = 'uniform'
off = 50
dimensions = [4, 6, 8, 10, 20]
schemes = ['baseline', 'rp', 'nord', 'flov', 'opt_flov']
paper_schemes = ['Baseline', 'RP', 'NoRD', 'FLOV', 'FLOV+']
rp_schemes = ['rpa', 'rpc', 'norp']
injection_rates = []
for i in range(1, 101, 1):
injection_rates.append("%.2f" % (float(i) / 100))
saturations = np.zeros((int(len(dimensions)), int(len(schemes))),
dtype=np.float)
latencies = []
powers = []
for d, dimension in enumerate(dimensions):
latencies.append(
np.zeros((int(len(schemes)), int(len(injection_rates))),
dtype=np.float))
powers.append(
np.zeros((int(len(schemes)), int(len(injection_rates))),
dtype=np.float))
for d, dimension in enumerate(dimensions):
for s, scheme in enumerate(schemes):
for i, injection_rate in enumerate(injection_rates):
if schemes[s] == 'rp':
rp_idx = 0
#power = None
latency = None
for j, rp in enumerate(rp_schemes):
rpfile = rp + '/' + str(
dimension
) + 'dim/' + traffic + '_' + injection_rate + 'inj_' + str(
dimension) + 'dim_' + str(off) + 'off.log'
if os.path.exists(rpfile):
infile = open(rpfile)
for l, line in enumerate(infile):
if 'Packet latency average' in line and 'samples' in line:
line = line.split()
if latency == None:
rp_idx = j
latency = float(line[4])
elif latency > 1.25 * float(line[4]):
rp_idx = j
latency = float(line[4])
break
scheme = rp_schemes[rp_idx]
filename = scheme + '/' + str(
dimension
) + 'dim/' + traffic + '_' + injection_rate + 'inj_' + str(
dimension) + 'dim_' + str(off) + 'off.log'
if os.path.exists(filename):
infile = open(filename)
for l, line in enumerate(infile):
if 'Packet latency average' in line and 'samples' in line:
line = line.split()
latencies[d][s][i] = float(line[4])
if float(line[4]) > 500 and saturations[d][s] == 0:
saturations[d][s] = float(injection_rate)
if 'Total Power:' in line:
line = line.split()
powers[d][s][i] = float(line[3])
break
else:
latencies[d][s][i] = float(1000)
paper_inj_rates = []
paper_indices = []
for d, dimension in enumerate(dimensions):
paper_inj_rates.append([])
paper_indices.append([])
for s, scheme in enumerate(schemes):
saturation = int(math.ceil(saturations[d][s] * 100))
paper_inj_rates[d].append([])
paper_inj_rates[d][s].append("0.01")
gap = 5
if dimension == 20:
gap = 2
for i in range(gap, saturation - 3, gap):
paper_inj_rates[d][s].append("%.2f" % (float(i) / 100))
for i in range(saturation - 3, saturation + 1, 1):
paper_inj_rates[d][s].append("%.2f" % (float(i) / 100))
inj_rate_set = set(paper_inj_rates[d][s])
paper_indices[d].append([
i for i, ele in enumerate(injection_rates)
if ele in inj_rate_set
])
paper_inj_rates[d][s] = [
float(rate) for i, rate in enumerate(paper_inj_rates[d][s])
]
# figure generation
plt.rc('font', size=26)
plt.rc('legend', fontsize=20)
# matlab colors
colors = [
'#b7312c', '#f2a900', '#48a23f', '#00a9e0', '#004b87', '#715091',
'#636569', '#0076a8', '#d78825'
]
markers = ['x', 'o', 'd', '^', 's', 'p', 'v', 'D', 'x']
linestyles = ['-', '-', '-', '-', '-', '-', '-']
for d, dimension in enumerate(dimensions):
figname = traffic + '_' + str(dimension) + 'dim_50off_throughput.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 8), fontsize=28)
ax = fig.gca()
for s, scheme in enumerate(paper_schemes):
ax.plot(paper_inj_rates[d][s],
latencies[d][s, paper_indices[d][s]],
marker=markers[s],
markersize=9,
markeredgewidth=2,
markeredgecolor=colors[s],
fillstyle='none',
color=colors[s],
linestyle=linestyles[s],
linewidth=2,
label=scheme)
ax.set_ylabel('Average Packet Latency (Cycles)')
ax.set_xlabel('injection rate (flits/cycle/core)')
ax.yaxis.grid(True, linestyle='--', color='black')
hdls, lab = ax.get_legend_handles_labels()
if dimension != 20:
legend = ax.legend(
hdls,
lab,
loc='upper left',
#bbox_to_anchor=(0, 1.2),
ncol=1,
frameon=True,
fontsize=22,
handletextpad=0.5,
columnspacing=1)
else:
legend = ax.legend(hdls,
lab,
loc='upper left',
bbox_to_anchor=(0.16, 1),
ncol=1,
frameon=True,
fontsize=22,
handletextpad=0.5,
columnspacing=1)
legend.get_frame().set_edgecolor('white')
ax.set_ylim(0, 500)
fig.subplots_adjust(top=0.85, bottom=0.2, left=0.15)
pdf.plot_teardown(pdfpage, fig)
for d, dimension in enumerate(dimensions):
figname = traffic + '_' + str(dimension) + 'dim_50off_power.pdf'
pdfpage, fig = pdf.plot_setup(figname, figsize=(8, 8), fontsize=28)
ax = fig.gca()
if dimension == 4:
axins = zoomed_inset_axes(
ax, 1.8, loc=4) # zoom-factor: 1.8, location: lower-right
elif dimension == 20:
axins = zoomed_inset_axes(
ax, 1.5, loc=4) # zoom-factor: 2, location: lower-right
else:
axins = zoomed_inset_axes(
ax, 2, loc=4) # zoom-factor: 2, location: lower-right
for s, scheme in enumerate(paper_schemes):
ax.plot(paper_inj_rates[d][s][0:-1],
powers[d][s, paper_indices[d][s][0:-1]],
marker=markers[s],
markersize=9,
markeredgewidth=2,
markeredgecolor=colors[s],
fillstyle='none',
color=colors[s],
linestyle=linestyles[s],
linewidth=2,
label=scheme)
axins.plot(paper_inj_rates[d][s][0:-1],
powers[d][s, paper_indices[d][s][0:-1]],
marker=markers[s],
markersize=9,
markeredgewidth=2,
markeredgecolor=colors[s],
fillstyle='none',
color=colors[s],
linestyle=linestyles[s],
linewidth=2,
label=scheme)
ax.set_ylabel('NoC Power (Watts)')
ax.set_xlabel('injection rate (flits/cycle/core)')
ax.yaxis.grid(True, linestyle='--', color='black')
if dimension == 10:
ax.yaxis.set_major_formatter(plticker.FormatStrFormatter('%.1f'))
hdls, lab = ax.get_legend_handles_labels()
legend = ax.legend(hdls,
lab,
loc='upper left',
ncol=1,
frameon=True,
fontsize=20,
handletextpad=0.5,
columnspacing=1)
legend.get_frame().set_edgecolor('white')
if dimension == 4:
x1, x2, y1, y2 = 0.1, 0.3, 0.14, 0.35 # specify the limits
loc = plticker.MultipleLocator(base=0.05)
axins.yaxis.set_major_locator(loc)
elif dimension == 6:
x1, x2, y1, y2 = 0, 0.15, 0.2, 0.8 # specify the limits
loc = plticker.MultipleLocator(base=0.15)
axins.yaxis.set_major_locator(loc)
elif dimension == 8:
x1, x2, y1, y2 = 0, 0.15, 0.3, 1.5 # specify the limits
loc = plticker.MultipleLocator(base=0.3)
axins.yaxis.set_major_locator(loc)
elif dimension == 10:
x1, x2, y1, y2 = 0, 0.15, 0.3, 2 # specify the limits
loc = plticker.MultipleLocator(base=0.5)
axins.yaxis.set_major_locator(loc)
elif dimension == 20:
x1, x2, y1, y2 = 0, 0.10, 2.5, 10 # specify the limits
loc = plticker.MultipleLocator(base=2)
axins.yaxis.set_major_locator(loc)
axins.set_xlim(x1, x2) # apply the x-limits
axins.set_ylim(y1, y2) # apply the y-limits
axins.yaxis.grid(True, linestyle='--', color='black')
axins.xaxis.set_ticklabels([])
axins.yaxis.set_ticklabels([])
axins.xaxis.set_ticks_position('none')
axins.yaxis.set_ticks_position('none')
mark_inset(ax, axins, loc1=2, loc2=3, fc="none", lw=1)
fig.subplots_adjust(top=0.85, bottom=0.2, left=0.15)
pdf.plot_teardown(pdfpage, fig)
plt.show()
