def periodic(self, time, time_delta):
if self.max_snapshots and self.num_snapshots > self.max_snapshots:
self.num_snapshots /= 2
for t in range(self.interval, time, self.interval * 2):
sim.util.db_delete('periodic-%d' % t)
self.interval *= 2
if time >= self.next_interval:
self.num_snapshots += 1
sim.stats.write('periodic-%d' %
(self.num_snapshots * self.interval))
#################################################
######### snapshot_last #########################
snapshot_last = sniper_lib.get_results(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' %
((self.num_snapshots - 1) * self.interval),
'periodic-%d' %
((self.num_snapshots) * self.interval)))['results']
snapshot_all = sniper_lib.get_results(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' % (0 * self.interval), 'periodic-%d' %
((self.num_snapshots) * self.interval)))['results']
CoreIns = snapshot_last['core.instructions']
IdleTime = snapshot_last['performance_model.idle_elapsed_time']
BusyTime = snapshot_last['performance_model.nonidle_elapsed_time']
CycleCount = snapshot_last['performance_model.cycle_count']
TotalTime = snapshot_last['performance_model.elapsed_time']
Futex = snapshot_last['performance_model.cpiSyncFutex']
L3_uncore_total_time = snapshot_last['L3.uncore-totaltime']
nonidle_elapsed_total_time = snapshot_last[
'performance_model.nonidle_elapsed_time']
cpu_base_time = snapshot_last['interval_timer.cpiBase']
stall_list = ['cpiBranchPredictor','cpiDataCachecache-remote','cpiDataCachedram','cpiDataCachedram-cache','cpiDataCachedram-local',\
'cpiDataCachedram-remote','cpiDataCacheL1','cpiDataCacheL1_S','cpiDataCacheL1I',\
'cpiDataCacheL2','cpiDataCacheL2_S','cpiDataCacheL3','cpiDataCacheL3_S','cpiDataCachemiss',\
'cpiDataCachenuca-cache','cpiDataCachepredicate-false','cpiDataCacheprefetch-no-mapping','cpiDataCacheunknown',\
'cpiInstructionCachecache-remote','cpiInstructionCachedram','cpiInstructionCachedram-cache',\
'cpiInstructionCachedram-local','cpiInstructionCachedram-remote','cpiInstructionCacheL1','cpiInstructionCacheL1_S',\
'cpiInstructionCacheL1I','cpiInstructionCacheL2','cpiInstructionCacheL2_S','cpiInstructionCacheL3',\
'cpiInstructionCacheL3_S','cpiInstructionCachemiss','cpiInstructionCachenuca-cache',\
'cpiInstructionCachepredicate-false','cpiInstructionCacheprefetch-no-mapping',\
'cpiInstructionCacheunknown','cpiLongLatency','cpiSerialization']
for core in range(sim.config.ncores):
self.IdleTimePerc[core] = float(IdleTime[core]) / float(
TotalTime[core])
IPC = []
CPI = []
stall = []
stall_cpi = []
stall_time = [
] #contains percentage of stall time/total time of the period
cpu_busy_time = []
futex_time = []
stall_total_time = [] #contains counter time for for all the run
L3_uncore_time = []
nonidle_elapsed_time = []
for core in range(sim.config.ncores):
stall.append(0)
stall_cpi.append(0.0)
stall_time.append(0.0)
IPC.append(0.0)
CPI.append(0.0)
cpu_busy_time.append(0.0)
futex_time.append(0.0)
stall_total_time.append(0)
L3_uncore_time.append(0)
nonidle_elapsed_time.append(0.0)
for name in stall_list:
stall_temp = snapshot_last['interval_timer.%s' % name]
stall_temp_all = snapshot_all['interval_timer.%s' % name]
for core in range(sim.config.ncores):
stall[core] += stall_temp[core]
stall_total_time[core] += stall_temp_all[core]
for core in range(sim.config.ncores):
#stall_cpi[core] = float(stall[core]) / (CoreIns[core]*sim.dvfs.get_frequency(core) )
stall_time[core] = float(stall[core]) / TotalTime[core]
cpu_busy_time[core] = 1 - (self.IdleTimePerc[core] +
stall_time[core])
#cpu_busy_time[core]= cpu_base_time[core]
futex_time[core] = float(Futex[core]) / TotalTime[core]
L3_uncore_time[core] = float(
L3_uncore_total_time[core]) / TotalTime[core]
nonidle_elapsed_time[core] = float(
nonidle_elapsed_total_time[core]) / TotalTime[core]
print 'stall[%s]=%s\n' % (core, stall[core])
# print 'cpi_stall[%s]=%s\n'%(core,stall_cpi[core])
print 'time_stall[%s]=%s\n' % (core, stall_time[core])
print 'idletimePerc[%s]=%s\n' % (core, self.IdleTimePerc[core])
print 'non-stall-busy-time[%s]=%s\n' % (
core, 1 - (self.IdleTimePerc[core] + stall_time[core]))
for core in range(sim.config.ncores):
self.IdleTimePerc[core] = float(IdleTime[core]) / float(
TotalTime[core])
IdleTimePercentage = IdleTime[0] / TotalTime[0]
BusyTimePercentage = BusyTime[0] / TotalTime[
0] #just for the first core
##############CoreIns##############################################################
self.Wfile_CoreIns = file(
os.path.join(sim.config.output_dir, self.filename_CoreIns),
'a')
self.Wfile_CoreIns.write('\n')
self.Wfile_CoreIns.write('%d\t' % (self.num_snapshots))
self.Wfile_CoreIns.write('CoreIns')
for core in range(sim.config.ncores):
self.Wfile_CoreIns.write("\t%s" % CoreIns[core])
self.Wfile_CoreIns.close()
##############IdleTime##############################################################
self.Wfile_IdleTime = file(
os.path.join(sim.config.output_dir, self.filename_IdleTime),
'a')
self.Wfile_IdleTime.write('\n')
self.Wfile_IdleTime.write('%d\t' % (self.num_snapshots))
self.Wfile_IdleTime.write('IdleTime')
for core in range(sim.config.ncores):
self.Wfile_IdleTime.write("\t%s" % IdleTime[core])
self.Wfile_IdleTime.close()
##############IdleTimePerc##############################################################
self.Wfile_IdleTimePerc = file(
os.path.join(sim.config.output_dir,
self.filename_IdleTimePerc), 'a')
self.Wfile_IdleTimePerc.write('\n')
self.Wfile_IdleTimePerc.write('%d\t' % (self.num_snapshots))
self.Wfile_IdleTimePerc.write('IdleTimePerc')
for core in range(sim.config.ncores):
self.Wfile_IdleTimePerc.write("\t%f" % self.IdleTimePerc[core])
self.Wfile_IdleTimePerc.close()
########################################################################################
#for core in range(sim.config.ncores):
# print ((sim.dvfs.get_frequency(core)/1000.0)*(self.interval/1000000))
#raw_input()
############## IPC ##############################################################
self.Wfile_IPC = file(
os.path.join(sim.config.output_dir, self.filename_IPC), 'a')
self.Wfile_IPC.write('\n')
self.Wfile_IPC.write('%d\t' % (self.num_snapshots))
self.Wfile_IPC.write('IPC')
for core in range(sim.config.ncores):
self.Wfile_IPC.write(
"\t%f" % (int(CoreIns[core]) /
((sim.dvfs.get_frequency(core) / 1000.0) *
(self.interval / 1000000))))
IPC[core] = (int(CoreIns[core]) /
((sim.dvfs.get_frequency(core) / 1000.0) *
(self.interval / 1000000)))
self.Wfile_IPC.close()
############## CPI ##############################################################
self.Wfile_CPI = file(
os.path.join(sim.config.output_dir, self.filename_CPI), 'a')
self.Wfile_CPI.write('\n')
self.Wfile_CPI.write('%d\t' % (self.num_snapshots))
self.Wfile_CPI.write('CPI')
for core in range(sim.config.ncores):
if (CoreIns[core] == 0):
self.Wfile_CPI.write("\t0")
CPI[core] = 0.0
else:
#self.Wfile_CPI.write("\t%f"%(float(cpu_base_time[core])/CoreIns[core]))
#CPI[core]= float(cpu_base_time[core])/CoreIns[core]
self.Wfile_CPI.write("\t%f" % (1.0 / IPC[core]))
CPI[core] = 1.0 / IPC[core]
# if ((int(CoreIns[core])/((sim.dvfs.get_frequency(core)/1000.0)*(self.interval/1000000))) == 0):
# self.Wfile_CPI.write ("\tinf")
# else: self.Wfile_CPI.write("\t%f"%(1/(int(CoreIns[core])/((sim.dvfs.get_frequency(core)/1000.0)*(self.interval/1000000)))))
self.Wfile_CPI.close()
############## stall_time ##############################################################
self.Wfile_stall_time = file(
os.path.join(sim.config.output_dir, self.filename_stall_time),
'a')
self.Wfile_stall_time.write('\n')
self.Wfile_stall_time.write('%d\t' % (self.num_snapshots))
self.Wfile_stall_time.write('stall_time')
for core in range(sim.config.ncores):
self.Wfile_stall_time.write("\t%s" % stall_time[core])
self.Wfile_stall_time.close()
############## cpu_busy_time ############################################################## just the (busy_time - stalls)
self.Wfile_cpu_busy_time = file(
os.path.join(sim.config.output_dir,
self.filename_cpu_busy_time), 'a')
self.Wfile_cpu_busy_time.write('\n')
self.Wfile_cpu_busy_time.write('%d\t' % (self.num_snapshots))
self.Wfile_cpu_busy_time.write('cpu_busy_time')
for core in range(sim.config.ncores):
self.Wfile_cpu_busy_time.write("\t%s" % cpu_busy_time[core])
self.Wfile_cpu_busy_time.close()
##############L3_uncore_time##############################################################
self.Wfile_L3_uncore_time = file(
os.path.join(sim.config.output_dir,
self.filename_L3_uncore_time), 'a')
self.Wfile_L3_uncore_time.write('\n')
self.Wfile_L3_uncore_time.write('%d\t' % (self.num_snapshots))
self.Wfile_L3_uncore_time.write('L3_uncore_time')
for core in range(sim.config.ncores):
self.Wfile_L3_uncore_time.write("\t%s" % L3_uncore_time[core])
self.Wfile_L3_uncore_time.close()
############## timing_summary ############################################################## just the (busy_time - stalls)
self.Wfile_timing_summary = file(
os.path.join(sim.config.output_dir,
self.filename_timing_summary), 'a')
self.Wfile_timing_summary.write('\n')
self.Wfile_timing_summary.write('%d\t' % (self.num_snapshots))
self.Wfile_timing_summary.write('timing_summary')
for core in range(sim.config.ncores):
self.Wfile_timing_summary.write(
"\t----\t%s\t%s\t1\t%s\t%s\t%s\t%s\t%s\t%s\t%s" %
(CoreIns[core], IPC[core],
(1 - self.IdleTimePerc[core]), cpu_busy_time[core],
stall_time[core], L3_uncore_time[core], futex_time[core],
cpu_base_time[core], stall_total_time[core]))
self.Wfile_timing_summary.close()
################################ CacheMiss ########################################
#periodic stat in stats file,
#it also generates cachemiss files in the output
gen_simout.generate_simout(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' %
((self.num_snapshots - 1) * self.interval),
'periodic-%d' %
((self.num_snapshots) * self.interval)),
output=open(
os.path.join(sim.config.output_dir,
'stats/p%d.out' % self.num_snapshots), 'w'),
silent=True)
########################################################################################
print '\nperiodic-%d - periodic-%d\n' % (
(self.num_snapshots * self.interval),
((self.num_snapshots - 1)))
cycles = (
self.stats['time'][core].delta -
self.stats['ffwd_time'][core].delta
) * sim.dvfs.get_frequency(core) / 1e9 # convert fs to cycles
instrs = self.stats['instrs'][core].delta
ipc = instrs / (cycles or 1) # Avoid division by zero
#self.fd.write(' %.3f' % ipc)
# include fast-forward IPCs
cycles = self.stats['time'][core].delta * sim.dvfs.get_frequency(
core) / 1e9 # convert fs to cycles
instrs = self.stats['coreinstrs'][core].delta
ipc = instrs / (cycles or 1)
self.fd.write(' %.3f' % ipc)
self.fd.write('\n')
self.fd.write('periodic-%d' % (self.num_snapshots * self.interval))
self.next_interval += self.interval
def periodic(self, time, time_delta):
if self.max_snapshots and self.num_snapshots > self.max_snapshots:
self.num_snapshots /= 2
for t in range(self.interval, time, self.interval * 2):
sim.util.db_delete('periodic-%d' % t)
self.interval *= 2
if time >= self.next_interval:
self.num_snapshots += 1
sim.stats.write('periodic-%d' %
(self.num_snapshots * self.interval))
#################################################
######### snapshot_last #########################
snapshot_last = sniper_lib.get_results(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' %
((self.num_snapshots - 1) * self.interval),
'periodic-%d' %
((self.num_snapshots) * self.interval)))['results']
snapshot_all = sniper_lib.get_results(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' % (0 * self.interval), 'periodic-%d' %
((self.num_snapshots) * self.interval)))['results']
CoreIns = snapshot_last['core.instructions']
IdleTime = snapshot_last['performance_model.idle_elapsed_time']
BusyTime = snapshot_last['performance_model.nonidle_elapsed_time']
CycleCount = snapshot_last['performance_model.cycle_count']
TotalTime = snapshot_last['performance_model.elapsed_time']
Futex = snapshot_last['performance_model.cpiSyncFutex']
L3_uncore_total_time = snapshot_last['L3.uncore-totaltime']
nonidle_elapsed_total_time = snapshot_last[
'performance_model.nonidle_elapsed_time']
cpu_base_time = snapshot_last['interval_timer.cpiBase']
stall_list = ['cpiBranchPredictor','cpiDataCachecache-remote','cpiDataCachedram','cpiDataCachedram-cache','cpiDataCachedram-local',\
'cpiDataCachedram-remote','cpiDataCacheL1','cpiDataCacheL1_S','cpiDataCacheL1I',\
'cpiDataCacheL2','cpiDataCacheL2_S','cpiDataCacheL3','cpiDataCacheL3_S','cpiDataCachemiss',\
'cpiDataCachenuca-cache','cpiDataCachepredicate-false','cpiDataCacheprefetch-no-mapping','cpiDataCacheunknown',\
'cpiInstructionCachecache-remote','cpiInstructionCachedram','cpiInstructionCachedram-cache',\
'cpiInstructionCachedram-local','cpiInstructionCachedram-remote','cpiInstructionCacheL1','cpiInstructionCacheL1_S',\
'cpiInstructionCacheL1I','cpiInstructionCacheL2','cpiInstructionCacheL2_S','cpiInstructionCacheL3',\
'cpiInstructionCacheL3_S','cpiInstructionCachemiss','cpiInstructionCachenuca-cache',\
'cpiInstructionCachepredicate-false','cpiInstructionCacheprefetch-no-mapping',\
'cpiInstructionCacheunknown','cpiLongLatency','cpiSerialization']
for core in range(sim.config.ncores):
self.IdleTimePerc[core] = float(IdleTime[core]) / float(
TotalTime[core])
IPC = []
CPI = []
stall = []
stall_cpi = []
stall_time = [
] #contains percentage of stall time/total time of the period
cpu_busy_time = []
futex_time = []
stall_total_time = [] #contains counter time for for all the run
L3_uncore_time = []
nonidle_elapsed_time = []
for core in range(sim.config.ncores):
stall.append(0)
stall_cpi.append(0.0)
stall_time.append(0.0)
IPC.append(0.0)
CPI.append(0.0)
cpu_busy_time.append(0.0)
futex_time.append(0.0)
stall_total_time.append(0)
L3_uncore_time.append(0)
nonidle_elapsed_time.append(0.0)
for name in stall_list:
stall_temp = snapshot_last['interval_timer.%s' % name]
stall_temp_all = snapshot_all['interval_timer.%s' % name]
for core in range(sim.config.ncores):
stall[core] += stall_temp[core]
stall_total_time[core] += stall_temp_all[core]
for core in range(sim.config.ncores):
#stall_cpi[core] = float(stall[core]) / (CoreIns[core]*sim.dvfs.get_frequency(core) )
stall_time[core] = float(stall[core]) / TotalTime[core]
cpu_busy_time[core] = 1 - (self.IdleTimePerc[core] +
stall_time[core])
#cpu_busy_time[core]= cpu_base_time[core]
futex_time[core] = float(Futex[core]) / TotalTime[core]
L3_uncore_time[core] = float(
L3_uncore_total_time[core]) / TotalTime[core]
nonidle_elapsed_time[core] = float(
nonidle_elapsed_total_time[core]) / TotalTime[core]
print 'stall[%s]=%s\n' % (core, stall[core])
# print 'cpi_stall[%s]=%s\n'%(core,stall_cpi[core])
print 'time_stall[%s]=%s\n' % (core, stall_time[core])
print 'idletimePerc[%s]=%s\n' % (core, self.IdleTimePerc[core])
print 'non-stall-busy-time[%s]=%s\n' % (
core, 1 - (self.IdleTimePerc[core] + stall_time[core]))
for core in range(sim.config.ncores):
self.IdleTimePerc[core] = float(IdleTime[core]) / float(
TotalTime[core])
IdleTimePercentage = IdleTime[0] / TotalTime[0]
BusyTimePercentage = BusyTime[0] / TotalTime[
0] #just for the first core
##############CoreIns##############################################################
self.Wfile_CoreIns = file(
os.path.join(sim.config.output_dir, self.filename_CoreIns),
'a')
self.Wfile_CoreIns.write('\n')
self.Wfile_CoreIns.write('%d\t' % (self.num_snapshots))
self.Wfile_CoreIns.write('CoreIns')
for core in range(sim.config.ncores):
self.Wfile_CoreIns.write("\t%s" % CoreIns[core])
self.Wfile_CoreIns.close()
##############IdleTime##############################################################
self.Wfile_IdleTime = file(
os.path.join(sim.config.output_dir, self.filename_IdleTime),
'a')
self.Wfile_IdleTime.write('\n')
self.Wfile_IdleTime.write('%d\t' % (self.num_snapshots))
self.Wfile_IdleTime.write('IdleTime')
for core in range(sim.config.ncores):
self.Wfile_IdleTime.write("\t%s" % IdleTime[core])
self.Wfile_IdleTime.close()
##############IdleTimePerc##############################################################
self.Wfile_IdleTimePerc = file(
os.path.join(sim.config.output_dir,
self.filename_IdleTimePerc), 'a')
self.Wfile_IdleTimePerc.write('\n')
self.Wfile_IdleTimePerc.write('%d\t' % (self.num_snapshots))
self.Wfile_IdleTimePerc.write('IdleTimePerc')
for core in range(sim.config.ncores):
self.Wfile_IdleTimePerc.write("\t%f" % self.IdleTimePerc[core])
self.Wfile_IdleTimePerc.close()
########################################################################################
#for core in range(sim.config.ncores):
# print ((sim.dvfs.get_frequency(core)/1000.0)*(self.interval/1000000))
#raw_input()
############## IPC ##############################################################
self.Wfile_IPC = file(
os.path.join(sim.config.output_dir, self.filename_IPC), 'a')
self.Wfile_IPC.write('\n')
self.Wfile_IPC.write('%d\t' % (self.num_snapshots))
self.Wfile_IPC.write('IPC')
for core in range(sim.config.ncores):
self.Wfile_IPC.write(
"\t%f" % (int(CoreIns[core]) /
((sim.dvfs.get_frequency(core) / 1000.0) *
(self.interval / 1000000))))
IPC[core] = (int(CoreIns[core]) /
((sim.dvfs.get_frequency(core) / 1000.0) *
(self.interval / 1000000)))
self.Wfile_IPC.close()
############## CPI ##############################################################
self.Wfile_CPI = file(
os.path.join(sim.config.output_dir, self.filename_CPI), 'a')
self.Wfile_CPI.write('\n')
self.Wfile_CPI.write('%d\t' % (self.num_snapshots))
self.Wfile_CPI.write('CPI')
for core in range(sim.config.ncores):
if (CoreIns[core] == 0):
self.Wfile_CPI.write("\t0")
CPI[core] = 0.0
else:
#self.Wfile_CPI.write("\t%f"%(float(cpu_base_time[core])/CoreIns[core]))
#CPI[core]= float(cpu_base_time[core])/CoreIns[core]
self.Wfile_CPI.write("\t%f" % (1.0 / IPC[core]))
CPI[core] = 1.0 / IPC[core]
# if ((int(CoreIns[core])/((sim.dvfs.get_frequency(core)/1000.0)*(self.interval/1000000))) == 0):
# self.Wfile_CPI.write ("\tinf")
# else: self.Wfile_CPI.write("\t%f"%(1/(int(CoreIns[core])/((sim.dvfs.get_frequency(core)/1000.0)*(self.interval/1000000)))))
self.Wfile_CPI.close()
############## stall_time ##############################################################
self.Wfile_stall_time = file(
os.path.join(sim.config.output_dir, self.filename_stall_time),
'a')
self.Wfile_stall_time.write('\n')
self.Wfile_stall_time.write('%d\t' % (self.num_snapshots))
self.Wfile_stall_time.write('stall_time')
for core in range(sim.config.ncores):
self.Wfile_stall_time.write("\t%s" % stall_time[core])
self.Wfile_stall_time.close()
############## cpu_busy_time ############################################################## just the (busy_time - stalls)
self.Wfile_cpu_busy_time = file(
os.path.join(sim.config.output_dir,
self.filename_cpu_busy_time), 'a')
self.Wfile_cpu_busy_time.write('\n')
self.Wfile_cpu_busy_time.write('%d\t' % (self.num_snapshots))
self.Wfile_cpu_busy_time.write('cpu_busy_time')
for core in range(sim.config.ncores):
self.Wfile_cpu_busy_time.write("\t%s" % cpu_busy_time[core])
self.Wfile_cpu_busy_time.close()
##############L3_uncore_time##############################################################
self.Wfile_L3_uncore_time = file(
os.path.join(sim.config.output_dir,
self.filename_L3_uncore_time), 'a')
self.Wfile_L3_uncore_time.write('\n')
self.Wfile_L3_uncore_time.write('%d\t' % (self.num_snapshots))
self.Wfile_L3_uncore_time.write('L3_uncore_time')
for core in range(sim.config.ncores):
self.Wfile_L3_uncore_time.write("\t%s" % L3_uncore_time[core])
self.Wfile_L3_uncore_time.close()
############## timing_summary ############################################################## just the (busy_time - stalls)
self.Wfile_timing_summary = file(
os.path.join(sim.config.output_dir,
self.filename_timing_summary), 'a')
self.Wfile_timing_summary.write('\n')
self.Wfile_timing_summary.write('%d\t' % (self.num_snapshots))
self.Wfile_timing_summary.write('timing_summary')
for core in range(sim.config.ncores):
self.Wfile_timing_summary.write(
"\t----\t%s\t%s\t1\t%s\t%s\t%s\t%s\t%s\t%s\t%s" %
(CoreIns[core], IPC[core],
(1 - self.IdleTimePerc[core]), cpu_busy_time[core],
stall_time[core], L3_uncore_time[core], futex_time[core],
cpu_base_time[core], stall_total_time[core]))
self.Wfile_timing_summary.close()
################################ CacheMiss ########################################
#periodic stat in stats file,
#it also generates cachemiss files in the output
gen_simout.generate_simout(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' %
((self.num_snapshots - 1) * self.interval),
'periodic-%d' %
((self.num_snapshots) * self.interval)),
output=open(
os.path.join(sim.config.output_dir,
'stats/p%d.out' % self.num_snapshots), 'w'),
silent=True)
########################################################################################
print '\nperiodic-%d - periodic-%d\n' % (
(self.num_snapshots * self.interval),
((self.num_snapshots - 1)))
print 'CoreIns= %s' % CoreIns
print 'IdleTime= %s' % IdleTime
print 'BusyTime= %s' % BusyTime
print 'CycleCount= %s' % CycleCount
print 'TotalTime= %s' % TotalTime
##############################################################
################# Kalman #####################################
#self.predicted_CoreIns[core][self.num_snapshots-1]
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_CoreIns),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_CoreIns)))
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_CPI),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_CPI)))
'''
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_IdleTimePerc),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_IdleTimePerc)))
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_IPC),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_IPC)))
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_cpu_busy_time),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_cpu_busy_time)))
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_stall_time),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_stall_time)))
os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_L3_uncore_time),\
os.path.join(sim.config.output_dir, self.filename_kalmanOut_L3_uncore_time)))
'''
#os.system ("%skalman/build/kalman-test %s %s"%(sniper_path, os.path.join(sim.config.output_dir, self.filename_Workload), os.path.join(sim.config.output_dir, self.filename_kalmanOut_Workload)))
##############################################################
############### Get Kalman predicted results ################
######### kalmanOut_CoreIns
self.Rfile_kalmanOut_CoreIns = file(
os.path.join(sim.config.output_dir,
self.filename_kalmanOut_CoreIns), 'r')
total_line_count = -1
for line in self.Rfile_kalmanOut_CoreIns:
total_line_count += 1
self.Rfile_kalmanOut_CoreIns = file(
os.path.join(sim.config.output_dir,
self.filename_kalmanOut_CoreIns), 'r')
line_count = -1
for line in self.Rfile_kalmanOut_CoreIns:
line_splitted = line.split('\t')
line_count += 1
if (line_count >= 2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_CoreIns[core].append(
float(line_splitted[5 * core +
3])) #offset=3 in the file
'''
#note: self.predicted_CoreIns[core][self.num_snapshots-1] shows the last prediction for core= ...
######## kalmanOut_IdleTimePerc
self.Rfile_kalmanOut_IdleTimePerc = file(os.path.join(sim.config.output_dir, self.filename_kalmanOut_IdleTimePerc), 'r')
line_count=-1
for line in self.Rfile_kalmanOut_IdleTimePerc:
line_splitted = line.split('\t')
line_count+=1
if (line_count>=2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_IdleTimePerc[core].append(float(line_splitted[5*core+3])) #offset=3 in the file
######## kalmanOut_IPC
self.Rfile_kalmanOut_IPC = file(os.path.join(sim.config.output_dir, self.filename_kalmanOut_IPC), 'r')
line_count=-1
for line in self.Rfile_kalmanOut_IPC:
line_splitted = line.split('\t')
line_count+=1
if (line_count>=2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_IPC[core].append(float(line_splitted[5*core+3])) #offset=3 in the file
######## kalmanOut_cpu_busy_time
self.Rfile_kalmanOut_cpu_busy_time = file(os.path.join(sim.config.output_dir, self.filename_kalmanOut_cpu_busy_time), 'r')
line_count=-1
for line in self.Rfile_kalmanOut_cpu_busy_time:
line_splitted = line.split('\t')
line_count+=1
if (line_count>=2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_cpu_busy_time[core].append(float(line_splitted[5*core+3])) #offset=3 in the file
######## kalmanOut_stall_time
self.Rfile_kalmanOut_stall_time = file(os.path.join(sim.config.output_dir, self.filename_kalmanOut_stall_time), 'r')
line_count=-1
for line in self.Rfile_kalmanOut_stall_time:
line_splitted = line.split('\t')
line_count+=1
if (line_count>=2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_stall_time[core].append(float(line_splitted[5*core+3])) #offset=3 in the file
'''
######## kalmanOut_CPI
self.Rfile_kalmanOut_CPI = file(
os.path.join(sim.config.output_dir,
self.filename_kalmanOut_CPI), 'r')
line_count = -1
for line in self.Rfile_kalmanOut_CPI:
line_splitted = line.split('\t')
line_count += 1
if (line_count >= 2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_CPI[core].append(
float(line_splitted[5 * core +
3])) #offset=3 in the file
'''
######## kalmanOut_L3_uncore_time
self.Rfile_kalmanOut_L3_uncore_time = file(os.path.join(sim.config.output_dir, self.filename_kalmanOut_L3_uncore_time), 'r')
line_count=-1
for line in self.Rfile_kalmanOut_L3_uncore_time:
line_splitted = line.split('\t')
line_count+=1
if (line_count>=2) and (line_count == total_line_count):
for core in range(sim.config.ncores):
self.predicted_L3_uncore_time[core].append(float(line_splitted[5*core+3])) #offset=3 in the file
'''
######## kalmanOut_Workload
#self.Rfile_kalmanOut_Workload = file(os.path.join(sim.config.output_dir, self.filename_kalmanOut_Workload), 'r')
#line_count=-1
#for line in self.Rfile_kalmanOut_Workload:
# print line
# line_splitted = line.split('\t')
# line_count+=1
# print line_count
# print total_line_count
# print "YEYEYEYEYE"
# if (line_count>=2) and (line_count == total_line_count-1):# -1
# print "yes"
# for core in range(sim.config.ncores):
# self.predicted_Workload[core].append(float(line_splitted[5*core+3])) #offset=3 in the file
print "last predictions for core 0: "
print "CoreIns: %s" % self.predicted_CoreIns[0][self.num_snapshots
- 1]
#print "IdleTimePerc: %s"%self.predicted_IdleTimePerc[0][self.num_snapshots-1]
#print "IPC: %s"%self.predicted_IPC[0][self.num_snapshots-1]
#print "cpu_cpu_busy_time: %s"%self.predicted_cpu_busy_time[0][self.num_snapshots-1]
#print "cpu_stall_time: %s"%self.predicted_stall_time[0][self.num_snapshots-1]
#print "L3_uncore_time: %s"%self.predicted_L3_uncore_time[0][self.num_snapshots-1]
print "CPI: %s" % self.predicted_CPI[0][self.num_snapshots - 1]
#print "Workload: %s"%self.predicted_Workload[0][self.num_snapshots-2]
#raw_input()
##############################################################
################# DVFS #######################################
if self.DVFS:
FreqList = [
'1000', '1100', '1200', '1300', '1400', '1500', '1600',
'1700', '1800', '1900', '2000'
]
AllowedPerformanceLoss = 0.50
freq_H = 2000.0
T = self.interval
self.fd.write('%u' % (time / 1e6)) # Time in ns
#currrent_freq = sim.dvfs.get_frequency(0)
#currrent_freq -= 100
#self.TotalWork+=1
for core in range(sim.config.ncores):
freq_P = sim.dvfs.get_frequency(core)
CPI_P = CPI[core]
I_P = CoreIns[core]
self.T_delay[core] += (I_P * (freq_H / freq_P - 1) *
CPI_P) / freq_H
self.T_ref[core] += (I_P * CPI_P) / freq_P
#self.T_delay[core] += (cpu_busy_time[core]*(freq_H/freq_P-1))/freq_H
#self.T_ref[core] += (cpu_busy_time[core])/freq_P
#self.T_delay[core] += (((freq_H/freq_P)-1)/freq_P)*(cpu_busy_time[core]/freq_H + L3_uncore_time[core]/freq_P) #multiplied by T
#self.T_ref[core] += ((cpu_busy_time[core] + L3_uncore_time[core])/freq_P*freq_P) #multiplied by T
#self.T_delay[core] += ((freq_H/freq_P)-1) * ( (freq_P/freq_H)*cpu_busy_time[core] + L3_uncore_time[core] )
#self.T_ref[core] += cpu_busy_time[core] + L3_uncore_time[core]
#self.T_delay[core] += ((freq_H/freq_P)-1) * ( (freq_P/freq_H)*cpu_busy_time[core] + stall_time[core] )
#self.T_ref[core] += cpu_busy_time[core] + stall_time[core]
#self.T_delay[core] += ((freq_H/freq_P)-1) * ( (freq_P/freq_H)*cpu_busy_time[core] )
#self.T_ref[core] += cpu_busy_time[core]
if self.T_ref[core] == 0:
self.PF[core] = 0
else:
self.PF[core] = self.T_delay[core] / self.T_ref[core]
print "PF[%d]=%s" % (core, self.PF[core])
print "PF[%d]=%s, delay=%s, ref=%s, freq=%s" % (
core, self.PF[core], self.T_delay[core],
self.T_ref[core], freq_P)
#raw_input()
#self.TotalInstDone[core]+= CoreIns[core]*(2000.0/sim.dvfs.get_frequency(core))
self.TotalInstDone[core] += CoreIns[core]
if (self.TotalInstDone[core] != 0):
self.InstLoss[core] = CoreIns[core] * (
freq_H / freq_P - 1)
self.InstDone[core] = CoreIns[core]
self.InstLossRate[core] = (
1 - (sim.dvfs.get_frequency(core) / 2000.0))
self.Inst_for_freq_H[core] = CoreIns[core] * (freq_H /
freq_P)
self.TotalInst_for_freq_H[
core] += self.Inst_for_freq_H[core]
self.TotallInstLoss[core] += CoreIns[core] * (
1 - (sim.dvfs.get_frequency(core) / 2000.0))
self.TotallInstDone[core] += CoreIns[core]
self.TotalInstLossRate[core] = self.TotallInstLoss[
core] / self.TotalInstDone[core]
#self.ExpectedWorkDone[core]+=(2000/sim.dvfs.get_frequency(core))
#ExpectedRemainedWork[core]=TotalWork-ExpectedWorkDone[core]
self.fd.write(' f: %.2fGHz' %
(sim.dvfs.get_frequency(core) / 1000.0))
#raw_input()
##############SummaryDVFS##############################################################
self.Wfile_SummaryDVFS = file(
os.path.join(sim.config.output_dir,
self.filename_SummaryDVFS), 'a')
self.Wfile_SummaryDVFS.write('\n')
self.Wfile_SummaryDVFS.write('%d\t' % (self.num_snapshots))
self.Wfile_SummaryDVFS.write('CoreIns')
for core in range(sim.config.ncores):
self.Wfile_SummaryDVFS.write("\t\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t"%(core,sim.dvfs.get_frequency(core),self.InstDone[core],\
self.PredictedInstDone[core],self.Inst_for_freq_H[core],self.PredictedInst_for_freq_H[core],self.InstLoss[core],\
self.PredictedInstLoss[core],self.InstLossRate[core],self.PredictedInstLossRate[core],self.TotallInstDone[core],\
self.PredictedTotalInstDone[core],self.TotalInstLossRate[core],self.PredictedTotalInstLossRate[core],self.PF[core],self.PF_next[core]))
self.Wfile_SummaryDVFS.close()
########################################################################################
for core in range(sim.config.ncores):
if (self.num_snapshots > 2):
freq_set = 0
for freq in FreqList: #from low freq to high freq
freq_P_next = float(freq)
if (freq_set == 0):
CPI_P_next = self.predicted_CPI[core][
self.num_snapshots - 1]
I_P_next = self.predicted_CoreIns[core][
self.num_snapshots - 1]
#cpu_busy_time_next = self.predicted_cpu_busy_time[core][self.num_snapshots-1]
#L3_uncore_time_next = self.predicted_L3_uncore_time[core][self.num_snapshots-1]
#stall_time_next = self.predicted_stall_time[core][self.num_snapshots-1]
self.T_delay_next[core] = (
I_P_next * (freq_H / freq_P_next - 1) *
CPI_P_next) / freq_H + self.T_delay[core]
self.T_ref_next[core] = (
I_P_next * CPI_P_next
) / freq_P_next + self.T_ref[core]
#self.T_delay_next[core] = (int(self.predicted_cpu_busy_time[core][self.num_snapshots-1])*(freq_H/freq_P_next-1))/freq_H + self.T_delay[core]
#self.T_ref_next[core] = int(self.predicted_cpu_busy_time[core][self.num_snapshots-1])/freq_P_next + self.T_ref[core]
#self.T_delay_next[core] = (((freq_H/freq_P_next)-1)/freq_P_next)*(cpu_busy_time_next/freq_H + L3_uncore_time_next/freq_P_next)+self.T_delay[core]
#self.T_ref_next[core] = ((cpu_busy_time_next + L3_uncore_time_next)/freq_P_next*freq_P_next)+self.T_ref[core]
#self.T_delay_next[core] = ((freq_H/freq_P_next)-1) * ( (freq_P_next/freq_H)*cpu_busy_time_next + L3_uncore_time_next ) + self.T_delay[core]
#self.T_ref_next[core] = cpu_busy_time_next + L3_uncore_time_next + self.T_ref[core]
#self.T_delay_next[core] = ((freq_H/freq_P_next)-1) * ( (freq_P_next/freq_H)*cpu_busy_time_next + stall_time_next ) + self.T_delay[core]
#self.T_ref_next[core] = cpu_busy_time_next + stall_time_next + self.T_ref[core]
#self.T_delay_next[core] = ((freq_H/freq_P_next)-1) * ( (freq_P_next/freq_H)*cpu_busy_time_next ) + self.T_delay[core]
#self.T_ref_next[core] = cpu_busy_time_next + self.T_ref[core]
if self.T_ref_next[core] == 0:
self.PF_next[core] = 0
else:
self.PF_next[core] = self.T_delay_next[
core] / self.T_ref_next[core]
print "PF_next[%d]=%s,delay=%s,ref=%s,freq_next=%s" % (
core, self.PF_next[core],
self.T_delay_next[core],
self.T_ref_next[core], freq_P_next)
#raw_input()
self.PredictedInstLoss[core] = int(
self.predicted_CoreIns[core][
self.num_snapshots -
1]) * (freq_H / freq_P_next - 1)
self.PredictedInstDone[
core] = self.predicted_CoreIns[core][
self.num_snapshots - 1]
self.PredictedInst_for_freq_H[
core] = self.predicted_CoreIns[core][
self.num_snapshots - 1] * (freq_H /
freq_P_next)
if self.PredictedInstDone[core] == 0:
self.PredictedInstLossRate[core] = 0
else:
self.PredictedInstLossRate[core] = float(
self.PredictedInstLoss[core]
) / self.PredictedInstDone[core]
self.PredictedTotalInst_for_freq_H[
core] = self.PredictedInst_for_freq_H[
core] + self.TotalInst_for_freq_H[core]
self.PredictedTotalInstLoss[
core] = self.PredictedInstLoss[
core] + self.TotallInstLoss[core]
self.PredictedTotalInstDone[
core] = self.PredictedInstDone[
core] + self.TotalInstDone[core]
if (self.PredictedTotalInstDone[core] == 0):
self.PredictedTotalInstLossRate[core] = 0
else:
self.PredictedTotalInstLossRate[
core] = float(
self.PredictedTotalInstLoss[core]
) / self.PredictedTotalInstDone[core]
#if (self.PredictedTotalInstLossRate[core] < AllowedPerformanceLoss):
if (self.PF_next[core] <
AllowedPerformanceLoss):
sim.dvfs.set_frequency(
core, int(freq_P_next))
freq_set = 1
if (
freq_set == 0
): #any of the frequencies not proper. we use the highest not to let the loss increase
sim.dvfs.set_frequency(core, int(freq_H))
#if (core==0)or(core==4)or(core==8)or(core==12):
#if (core==0):
# sim.dvfs.set_frequency(core,5000)
cycles = (self.stats['time'][core].delta -
self.stats['ffwd_time'][core].delta
) * sim.dvfs.get_frequency(
core) / 1e9 # convert fs to cycles
instrs = self.stats['instrs'][core].delta
ipc = instrs / (cycles or 1) # Avoid division by zero
#self.fd.write(' %.3f' % ipc)
# include fast-forward IPCs
cycles = self.stats['time'][
core].delta * sim.dvfs.get_frequency(
core) / 1e9 # convert fs to cycles
instrs = self.stats['coreinstrs'][core].delta
ipc = instrs / (cycles or 1)
self.fd.write(' %.3f' % ipc)
self.fd.write('\n')
#raw_input()
##############################################################
#os.system("/home/milad/sniper/tools/dumpstats.py --partial periodic-%d:periodic-%d | grep power.Core"%( ((self.num_snapshots-1) *self.interval), ((self.num_snapshots) *self.interval ) ) )
#raw_input(); #getch
self.fd.write('periodic-%d' % (self.num_snapshots * self.interval))
#periodic stat in stats file
#gen_simout.generate_simout(resultsdir = sim.config.output_dir, partial = ('periodic-%d' % ((self.num_snapshots-1) *self.interval), 'periodic-%d' % ((self.num_snapshots) *self.interval ) ), output = open(os.path.join(sim.config.output_dir, 'stats/p%d.out'%self.num_snapshots), 'w'), silent = True)
#gen_simout.generate_simout(resultsdir = sim.config.output_dir, partial = ('periodic-10000000000','periodic-20000000000'), output = open(os.path.join(sim.config.output_dir, 'stats/p%d.out'%self.num_snapshots), 'w'), silent = True)
self.next_interval += self.interval
def periodic(self, time, time_delta):
if self.max_snapshots and self.num_snapshots > self.max_snapshots:
self.num_snapshots /= 2
for t in range(self.interval, time, self.interval * 2):
sim.util.db_delete('periodic-%d' % t)
self.interval *= 2
if time >= self.next_interval:
self.num_snapshots += 1
sim.stats.write('periodic-%d' %
(self.num_snapshots * self.interval))
#################################################
######### snapshot_last #########################
snapshot_last = sniper_lib.get_results(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' %
((self.num_snapshots - 1) * self.interval),
'periodic-%d' %
((self.num_snapshots) * self.interval)))['results']
CoreIns = snapshot_last['core.instructions']
IdleTime = snapshot_last['performance_model.idle_elapsed_time']
BusyTime = snapshot_last['performance_model.nonidle_elapsed_time']
CycleCount = snapshot_last['performance_model.cycle_count']
TotalTime = snapshot_last['performance_model.elapsed_time']
for core in range(sim.config.ncores):
self.IdleTimePerc[core] = float(IdleTime[core]) / float(
TotalTime[core])
IdleTimePercentage = IdleTime[0] / TotalTime[0]
BusyTimePercentage = BusyTime[0] / TotalTime[
0] #just for the first core
##############CoreIns##############################################################
self.Wfile_CoreIns = file(
os.path.join(sim.config.output_dir, self.filename_CoreIns),
'a')
self.Wfile_CoreIns.write('\n')
self.Wfile_CoreIns.write('%d\t' % (self.num_snapshots))
self.Wfile_CoreIns.write('CoreIns')
for core in range(sim.config.ncores):
self.Wfile_CoreIns.write("\t%s" % CoreIns[core])
self.Wfile_CoreIns.close()
##############IdleTime##############################################################
self.Wfile_IdleTime = file(
os.path.join(sim.config.output_dir, self.filename_IdleTime),
'a')
self.Wfile_IdleTime.write('\n')
self.Wfile_IdleTime.write('%d\t' % (self.num_snapshots))
self.Wfile_IdleTime.write('IdleTime')
for core in range(sim.config.ncores):
self.Wfile_IdleTime.write("\t%s" % IdleTime[core])
self.Wfile_IdleTime.close()
##############IdleTimePerc##############################################################
self.Wfile_IdleTimePerc = file(
os.path.join(sim.config.output_dir,
self.filename_IdleTimePerc), 'a')
self.Wfile_IdleTimePerc.write('\n')
self.Wfile_IdleTimePerc.write('%d\t' % (self.num_snapshots))
self.Wfile_IdleTimePerc.write('IdleTimePerc')
for core in range(sim.config.ncores):
self.Wfile_IdleTimePerc.write("\t%f" % self.IdleTimePerc[core])
self.Wfile_IdleTimePerc.close()
########################################################################################
print '\nperiodic-%d - periodic-%d\n' % (
(self.num_snapshots * self.interval),
((self.num_snapshots - 1)))
print 'CoreIns= %s' % CoreIns
print 'IdleTime= %s' % IdleTime
print 'BusyTime= %s' % BusyTime
print 'CycleCount= %s' % CycleCount
print 'TotalTime= %s' % TotalTime
##############################################################
################# Kalman #####################################
#self.predicted_CoreIns[core][self.num_snapshots-1]
os.system(
"%skalman/build/kalman-test %s %s" %
(sniper_path,
os.path.join(sim.config.output_dir, self.filename_CoreIns),
os.path.join(sim.config.output_dir, self.filename_kalmanOut)))
##############################################################
############### Get Kalman predicted results ################
self.Rfile_kalmanOut = file(
os.path.join(sim.config.output_dir, self.filename_kalmanOut),
'r')
total_line_count = -1
for line in self.Rfile_kalmanOut:
total_line_count += 1
self.Rfile_kalmanOut = file(
os.path.join(sim.config.output_dir, self.filename_kalmanOut),
'r')
line_count = -1
for line in self.Rfile_kalmanOut:
line_splitted = line.split('\t')
line_count += 1
if (line_count >= 2) and (
line_count == total_line_count
): #stats_lines (we dont read last line, it just has the predicted value not the future one)
for core in range(sim.config.ncores):
self.predicted_CoreIns[core].append(
float(line_splitted[5 * core +
3])) #offset=4 in the file
##############################################################
################# DVFS #######################################
if self.DVFS:
self.fd.write('%u' % (time / 1e6)) # Time in ns
for core in range(sim.config.ncores):
# detailed-only IPC
self.fd.write(' f: %.2fGHz' %
(sim.dvfs.get_frequency(core) / 1000.0))
#raw_input()
#if (self.IdleTimePerc[core]>0.4):
#if (core==0):
if (self.num_snapshots % 2 == 0):
#if (self.predicted_CoreIns[core][self.num_snapshots-1] < 2000.0) :
sim.dvfs.set_frequency(core, 3000)
else:
sim.dvfs.set_frequency(core, 1500)
print "predicted: "
print self.predicted_CoreIns[core][self.num_snapshots - 1]
cycles = (self.stats['time'][core].delta -
self.stats['ffwd_time'][core].delta
) * sim.dvfs.get_frequency(
core) / 1e9 # convert fs to cycles
instrs = self.stats['instrs'][core].delta
ipc = instrs / (cycles or 1) # Avoid division by zero
#self.fd.write(' %.3f' % ipc)
# include fast-forward IPCs
cycles = self.stats['time'][
core].delta * sim.dvfs.get_frequency(
core) / 1e9 # convert fs to cycles
instrs = self.stats['coreinstrs'][core].delta
ipc = instrs / (cycles or 1)
self.fd.write(' %.3f' % ipc)
self.fd.write('\n')
##############################################################
#os.system("/home/milad/sniper/tools/dumpstats.py --partial periodic-%d:periodic-%d | grep power.Core"%( ((self.num_snapshots-1) *self.interval), ((self.num_snapshots) *self.interval ) ) )
#raw_input(); #getch
self.fd.write('periodic-%d' % (self.num_snapshots * self.interval))
gen_simout.generate_simout(
resultsdir=sim.config.output_dir,
partial=('periodic-%d' %
((self.num_snapshots - 1) * self.interval),
'periodic-%d' %
((self.num_snapshots) * self.interval)),
output=open(
os.path.join(sim.config.output_dir,
'stats/p%d.out' % self.num_snapshots), 'w'),
silent=True)
#gen_simout.generate_simout(resultsdir = sim.config.output_dir, partial = ('periodic-10000000000','periodic-20000000000'), output = open(os.path.join(sim.config.output_dir, 'stats/p%d.out'%self.num_snapshots), 'w'), silent = True)
self.next_interval += self.interval
