def mean_df():
def avg_ondemand(onds, arg):
ond = dvfsModel()
ond.loadData(filename='data/dvfs/ondemand/' + onds[0],
arg_num=arg,
method='constTime')
df = ond.dataFrame
for f in onds[1:]:
ond.loadData(filename='data/dvfs/ondemand/' + onds[0],
arg_num=arg,
method='constTime')
df['energy'] += ond.dataFrame['energy']
df['energy'] /= len(onds)
return df
ondemand = avg_ondemand(['ferret_completo_2.pkl', 'ferret_completo_3.pkl'],
6)
pw_model = powerModel('data/ipmi_2-32_cpuload.pw')
perf_model = performanceModel('data/dataframes/' + 'completo_ferret_3.pkl',
'data/svr/' + 'completo_ferret_3.pkl')
en_model = energyModel(pw_model, perf_model)
ond = ondemand[['in', 'thr', 'time', 'energy']].sort_values(['in', 'thr'])
nthreads = ond['thr'].unique().shape[0]
ond = pd.crosstab(ond['in'], ond['thr'], ond['energy'], aggfunc=min)
df = en_model.realMinimalEnergy().sort_values('in_cat')['energy']
df = pd.concat([df] * nthreads, axis=1)
ond = pd.DataFrame(ond.values / df.values, columns=ond.columns)
ond.plot.bar()
plt.plot([-1, 6], [1, 1], '--', color='k', label='proposto')
plt.title('Ferret')
plt.tight_layout()
plt.savefig('fotos/comp2/ferret.png')
def createPowerModel(path, save_model):
pw_model = powerModel()
pw_model.loadData(filename=path,
verbose=0,
load_sensors=False,
freqs_filter=get_range(args.freqs),
thrs_filter=get_range(args.thrs))
pw_model.fit()
pw_model.save(save_model)
error = pw_model.error()
print("Power model constants, ", pw_model.power_model_x)
print("Erro, ", error)
return pw_model
def visualizePowerModel(path):
# Plot the measured values and the model
pw_model = powerModel(path)
freqs = get_range(args.freqs) if args.freqs else pw_model.frequencies
thrs = get_range(args.thrs) if args.thrs else pw_model.threads
est = pw_model.estimate(freqs, thrs)
plotData.setProps(xlabel="Frequencies (GHz)",
ylabel="Active Cores",
zlabel="Power (W)")
plotData.plot3D(x=pw_model.frequencies,
y=pw_model.threads,
z=pw_model.powers,
legend='Measurements')
plotData.plot3D(x=freqs, y=thrs, z=est, points=False, legend='Model')
plotData.plotShow(showLegend=True)
def createPowerModel(path, save_model):
pw_model = powerModel(
power_model_=lambda x, f, p: x[0] * f**3 + x[1] * f + x[2],
power_mode_n_=3)
pw_model.loadData(filename=path,
verbose=2,
load_sensors=False,
freqs_filter=get_range(args.freqs),
thrs_filter=get_range(args.thrs))
pw_model.fit()
pw_model.save(save_model)
error = pw_model.error()
print("Power model constants, ", pw_model.power_model_x)
print("Erro, ", error)
return pw_model
def figures(appname=None, energy=True, in_cmp=3):
from energyOptimal import plotData
for app, title in zip(parsec_models, titles):
if (appname and not appname in app) or (not app):
continue
pw_model = powerModel('data/ipmi_2-32_cpuload.pw')
perf_model = performanceModel('data/dataframes/' + app,
'data/svr/' + app)
en_model = energyModel(pw_model,
perf_model,
freq_range_=np.arange(1.2e6, 2.3e6, 0.1e6) /
1e6)
plotData.setProps(xlabel='Frequencies (GHz)',
ylabel='Active threads',
zlabel='Energy (kJ)' if energy else 'Time (s)',
title=title)
df_ = perf_model.dataFrame[perf_model.dataFrame['in_cat'] ==
in_cmp].sort_values(['freq', 'thr'])
df_pred_ = en_model.dataFrame[en_model.dataFrame['in_cat'] ==
in_cmp].sort_values(['freq', 'thr'])
# df_pred_= df_pred_[df_pred_['thr'].isin(list(range(8,33,2)))]
# df_= df_[df_['thr'].isin(list(range(8,33,2)))]
plotData.plot3D(x=df_['freq'].unique(),
y=df_['thr'].unique(),
z=df_['energy'].values /
1e3 if energy else df_['time'].values,
points=True,
legend='Measurements')
plotData.plot3D(x=df_pred_['freq'].unique(),
y=df_pred_['thr'].unique(),
z=df_pred_['energy_model'].values /
1e3 if energy else df_pred_['time'].values,
points=False,
legend='Model')
plotData.ax.view_init(30, 60)
if 'HPL' in app:
plotData.ax.set_zlim(0, 15)
aux = 'energy' if energy else 'time'
plotData.savePlot('fotos/{}/{}.png'.format(aux, app), showLegend=True)
def comparation(appname=None,
proposed_bar=False,
relative=True,
thrs_filter=[]):
row = []
for title, dvfs, model, arg in zip(titles, parsec_dvfs, parsec_models,
parsecapps_argnum):
if 'freq' in model or not model:
continue
if appname and not appname in dvfs:
continue
ondemand = dvfsModel()
ondemand.loadData(filename='data/dvfs/ondemand/' + dvfs,
arg_num=arg,
method='constTime')
pw_model = powerModel('data/ipmi_2-32_cpuload.pw')
perf_model = performanceModel('data/dataframes/' + model,
'data/svr/' + model)
en_model = energyModel(pw_model, perf_model)
#TODO verify if arguments match
ond = ondemand.dataFrame[['in', 'thr', 'time', 'energy']]
ond = pd.merge(ond, perf_model.dataFrame[[
'in', 'in_cat'
]]).drop_duplicates().sort_values(['in_cat', 'thr'])
if thrs_filter:
ond = ond[ond['thr'].isin(thrs_filter)]
ond_en = pd.crosstab(ond['in_cat'],
ond['thr'],
ond['energy'],
aggfunc=min)
ond_time = pd.crosstab(ond['in_cat'],
ond['thr'],
ond['time'],
aggfunc=min)
min_df = en_model.realMinimalEnergy().sort_values('in_cat')
if proposed_bar:
ond_en['proposed'] = min_df['energy'].values
ond_time['proposed'] = min_df['time'].values
if relative:
aux = pd.concat([min_df['energy']] * (len(ond_en.columns)), axis=1)
saving = pd.DataFrame(ond_en.values - aux.values,
columns=ond_en.columns)
ond_en = pd.DataFrame(ond_en.values / aux.values,
columns=ond_en.columns)
aux = pd.concat([min_df['time']] * (len(ond_en.columns)), axis=1)
ond_time = pd.DataFrame(ond_time.values / aux.values,
columns=ond_time.columns)
row.append([
dvfs,
ond_en.max(axis=1).mean(),
ond_en.mean(axis=1).mean(), ond_en[32].mean(),
ond_en.min(axis=1).mean(),
ond_time.max(axis=1).mean(),
ond_time.mean(axis=1).mean(), ond_time[32].mean(),
ond_time.min(axis=1).mean(),
saving.max(axis=1).sum(),
saving.median(axis=1).sum(), saving[32].sum(),
saving.min(axis=1).sum(),
perf_model.dataFrame.energy.sum()
])
ond_en.plot.bar(figsize=(12, 7))
if relative:
plt.plot([-1, 6], [1, 1], '--', color='k', label='proposed')
plt.plot([-1, 6], [ond_en.mean().mean(),
ond_en.mean().mean()],
':',
color='k',
label='average gain')
plt.xlabel('Inputs', fontsize=18)
plt.ylabel('Energy relative' if relative else 'Eenergy (J)',
fontsize=18)
plt.xticks(fontsize=18)
plt.yticks(fontsize=18)
plt.title(title, fontsize=22)
plt.legend(loc='center right', bbox_to_anchor=(1.2, 0.55), fontsize=12)
plt.tight_layout()
plt.savefig('fotos/relative/%s.png' % dvfs)
# plt.show()
if relative and not proposed_bar:
df = pd.DataFrame(row,
columns=[
'app', 'max_en', 'mean_en', '32_en', 'min_en',
'max_time', 'mean_time', '32_time', 'min_time',
'max_save', 'median_save', '32_save', 'min_save',
'train_energy'
])
df[[
'max_en', 'mean_en', '32_en', 'min_en', 'max_time', 'mean_time',
'32_time', 'min_time'
]] -= 1
df[[
'max_en', 'mean_en', '32_en', 'min_en', 'max_time', 'mean_time',
'32_time', 'min_time'
]] *= 100
df['max_run'] = df['train_energy'] / df['max_save']
df['median_run'] = df['train_energy'] / df['median_save']
df['32_run'] = df['train_energy'] / df['32_save']
df['min_run'] = df['train_energy'] / df['min_save']
df = df.sort_values('32_en', ascending=False)
df = pd.concat((df,
pd.DataFrame([['mean'] + list(df.mean().values)],
columns=df.columns)))
df.to_csv('tables/relative.csv')
print(df)
for r in str_range.split(';'):
sr = r.split(',')
if len(sr) >= 2:
start = float(sr[0])
stop = float(sr[1])
if len(sr) == 3:
step = float(sr[2])
else:
step = 1.0
_range += list(np.arange(start, stop, step))
elif len(sr) > 0:
_range += list([float(sr[0])])
return _range
pw_model = powerModel(args.path_power)
perf_model = performanceModel(args.path_dataframe, args.path_svr)
en_model = energyModel(pw_model,
perf_model,
thr_range_=get_range(args.thrs),
freq_range_=get_range(args.freqs))
df = perf_model.dataFrame.sort_values(['freq', 'thr'])
df_pred = en_model.dataFrame.sort_values(['freq', 'thr'])
print(en_model.minimalEnergy())
def update_data(val):
d = int(val)
plotData.setProps(xlabel='Frequencies (GHz)',
ylabel='Active threads',
from energyOptimal.powerModel import powerModel
from energyOptimal import plotData
import numpy as np
import pandas as pd
pw_model_full = powerModel(filename='data/ipmi_2-32_cpuload.pw')
print("Percetage error pw_mode full: {}".format(pw_model_full.error()))
thrs_filter = [[2, 32], [2, 16, 32], [2, 8, 16, 32], [2, 8, 16, 24, 32]]
freq_filter = [
[1.2, 2.2],
[1.2, 1.7, 2.2],
[1.2, 1.5, 1.7, 2.2],
[1.2, 1.5, 1.7, 2.0, 2.2],
]
table = []
for freq in freq_filter:
for thr in thrs_filter:
n_points = len(freq) * len(thr)
print("points {} freqs {} thrs {}".format(n_points, freq, thr))
pw_model = powerModel()
pw_model.loadData(filename='data/power_model/ipmi_2-32_cpuload.pkl',
freqs_filter=freq,
thrs_filter=thr)
pw_model.fit()
f_est, p_est = pw_model_full.frequencies, pw_model_full.threads
