bug fix, change unit to only watt or joule, modulate analyzer
This commit is contained in:
parent
42cb13f14d
commit
7779251e5a
|
|
@ -8,10 +8,29 @@ except:
|
|||
raise
|
||||
|
||||
|
||||
def read_cpu_log(filepath, startT=None, endT=None, isDelta=True):
|
||||
class EnergyAnalyzer():
|
||||
'''
|
||||
Energy analyzer
|
||||
'''
|
||||
def __init__(self, productname, isDebugging=False, unit="mW"):
|
||||
self.myModel = Model(isDebugging=isDebugging, unit=unit)
|
||||
self.myModel.load(productname)
|
||||
self.results = []
|
||||
self.deltas = []
|
||||
self.instant_power = []
|
||||
self.total_energy = 0 # unit as defined in unit
|
||||
self.avg_power = 0
|
||||
self.total_time = 0
|
||||
|
||||
self.DEBUG = isDebugging
|
||||
if self.DEBUG:
|
||||
self.logger = EmptyLogger(
|
||||
"EnergyAnalyzer", isDebugging=self.DEBUG, printout=True)
|
||||
|
||||
def read_cpu_log(self, filepath,
|
||||
startT=None, endT=None):
|
||||
self.logger.debug("read_cpu_log started")
|
||||
contents = []
|
||||
results = []
|
||||
deltas = []
|
||||
skipFirstTime = True
|
||||
with open(filepath, 'rU') as f:
|
||||
contents = f.readlines()
|
||||
|
|
@ -20,45 +39,46 @@ def read_cpu_log(filepath, startT=None, endT=None, isDelta=True):
|
|||
if len(tmp) < 3:
|
||||
print "something is wrong at splitting the line for cpu_log"
|
||||
sys.exit(-1)
|
||||
timestamp = int(tmp[0]) # ms
|
||||
timestamp = int(tmp[0]) / 1000.0 # ms -> s
|
||||
if (startT is not None and timestamp < startT) \
|
||||
or (endT is not None and timestamp > endT):
|
||||
continue
|
||||
cpu_total_idle = int(tmp[1])
|
||||
cpu_total_used = int(tmp[2])
|
||||
cpu_per_core = []
|
||||
if isDelta and not skipFirstTime:
|
||||
delta_t = timestamp - results[-1][0]
|
||||
delta_total_idle = cpu_total_idle - results[-1][1]
|
||||
delta_total_used = cpu_total_used - results[-1][2]
|
||||
if not skipFirstTime:
|
||||
delta_t = timestamp - self.results[-1][0]
|
||||
delta_total_idle = cpu_total_idle - self.results[-1][1]
|
||||
delta_total_used = cpu_total_used - self.results[-1][2]
|
||||
delta_per_core = []
|
||||
for i in xrange(3, len(tmp), 3):
|
||||
cpu_i_idle = int(tmp[i])
|
||||
cpu_i_used = int(tmp[i + 1])
|
||||
cpu_i_freq = int(tmp[i + 2])
|
||||
cpu_per_core.append([cpu_i_idle, cpu_i_used, cpu_i_freq])
|
||||
if isDelta and len(results) != 0:
|
||||
if len(self.results) != 0:
|
||||
delta_per_core.append(
|
||||
[cpu_i_idle - results[-1][3][i / 3 - 1][0],
|
||||
cpu_i_used - results[-1][3][i / 3 - 1][1],
|
||||
[cpu_i_idle - self.results[-1][3][i / 3 - 1][0],
|
||||
cpu_i_used - self.results[-1][3][i / 3 - 1][1],
|
||||
cpu_i_freq])
|
||||
if isDelta and not skipFirstTime:
|
||||
deltas.append(
|
||||
[delta_t, delta_total_idle, delta_total_used, delta_per_core])
|
||||
results.append(
|
||||
if not skipFirstTime:
|
||||
self.deltas.append(
|
||||
[delta_t, delta_total_idle,
|
||||
delta_total_used, delta_per_core])
|
||||
self.results.append(
|
||||
[timestamp, cpu_total_idle, cpu_total_used, cpu_per_core])
|
||||
skipFirstTime = False
|
||||
if isDelta:
|
||||
return deltas, results
|
||||
return results
|
||||
self.logger.debug("read_cpu_log ended")
|
||||
|
||||
def get_cpu_energy(self):
|
||||
if len(self.deltas) < 1:
|
||||
self.logger.error("get_cpu_energy finds delta empty")
|
||||
self.logger.error(self.results)
|
||||
return
|
||||
|
||||
def get_cpu_energy(results, model):
|
||||
energy = 0
|
||||
if len(results) < 1:
|
||||
return energy
|
||||
num_of_cores = len(results[0][3])
|
||||
for result in results:
|
||||
self.logger.debug("get_cpu_energy started")
|
||||
num_of_cores = len(self.deltas[0][3])
|
||||
for result in self.deltas:
|
||||
freqs = [0 for i in xrange(num_of_cores)]
|
||||
utils = [0 for i in xrange(num_of_cores + 1)]
|
||||
for i in xrange(num_of_cores):
|
||||
|
|
@ -73,7 +93,25 @@ def get_cpu_energy(results, model):
|
|||
utils[-1] = 1.0 * result[1] / (result[1] + result[2])
|
||||
else:
|
||||
utils[-1] = 0
|
||||
energy += model.get_cpu_energy(result[0] / 1000.0, freqs, utils[:-1])
|
||||
# get power (only if the unit is in Watts or mWatts)
|
||||
instant_power = self.myModel.get_cpu_energy(
|
||||
result[0], freqs, utils[:-1])
|
||||
if self.myModel.using_power:
|
||||
self.instant_power.append(instant_power)
|
||||
energy = instant_power * result[0]
|
||||
else:
|
||||
energy = instant_power
|
||||
self.total_time += result[0]
|
||||
self.total_energy += energy
|
||||
self.avg_power = self.total_energy / self.total_time
|
||||
|
||||
self.logger.info(
|
||||
"total energy: {0:.4f}mJ".format(self.total_energy))
|
||||
self.logger.info(
|
||||
"total time: {0:.4f}s".format(self.total_time))
|
||||
self.logger.info(
|
||||
"average power: {0:.4f}mW".format(self.avg_power))
|
||||
self.logger.debug("get_cpu_energy ended")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
@ -82,11 +120,9 @@ if __name__ == "__main__":
|
|||
if not os.path.isfile(cpuFile):
|
||||
print ".....!"
|
||||
sys.exit(-1)
|
||||
deltas, results = read_cpu_log(cpuFile, isDelta=True)
|
||||
myObj = Model(isDebuging=True, unit="mW")
|
||||
# myObj.load(sys.argv[1])
|
||||
myObj.load("shamu")
|
||||
get_cpu_energy(deltas, myObj)
|
||||
myObj = EnergyAnalyzer("shamu", isDebugging=True, unit="mW")
|
||||
myObj.read_cpu_log(cpuFile)
|
||||
myObj.get_cpu_energy()
|
||||
# for i in xrange(1, len(myObj.freqs)):
|
||||
# print myObj.freqs[i] - myObj.freqs[i-1]
|
||||
# myObj.get_wifi_tail_energy(1)
|
||||
|
|
|
|||
|
|
@ -33,9 +33,13 @@ class EmptyLogger:
|
|||
logger base
|
||||
'''
|
||||
def __init__(
|
||||
self, loggerTag, level=logging.DEBUG, logPath=None, printout=False
|
||||
self, loggerTag, isDebugging=False, logPath=None, printout=True
|
||||
):
|
||||
self.myLogger = logging.getLogger(loggerTag)
|
||||
if isDebugging:
|
||||
level = logging.DEBUG
|
||||
else:
|
||||
level = logging.INFO
|
||||
self.myLogger.setLevel(level)
|
||||
self.ch_file = None
|
||||
self.ch_stream = None
|
||||
|
|
@ -43,13 +47,12 @@ class EmptyLogger:
|
|||
'%(asctime)s %(name)s %(levelname)s, %(message)s')
|
||||
if logPath is not None:
|
||||
self.ch_file = logging.FileHandler(logPath, 'w')
|
||||
self.ch_file.setLevel(level)
|
||||
self.ch_file.setLevel(logging.DEBUG)
|
||||
self.ch_file.setFormatter(formatter)
|
||||
self.myLogger.addHandler(self.ch_file)
|
||||
if printout:
|
||||
self.ch_stream = logging.StreamHandler()
|
||||
self.ch_stream.setLevel(level)
|
||||
# ch_stream.setLevel(level)
|
||||
self.ch_stream.setFormatter(formatter)
|
||||
self.myLogger.addHandler(self.ch_stream)
|
||||
self.myLogger.info('logging started')
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ class Model():
|
|||
The energy model module
|
||||
'''
|
||||
|
||||
def __init__(self, isDebuging=False, unit="mW"):
|
||||
def __init__(self, isDebugging=False, unit="mW"):
|
||||
self.freqs = []
|
||||
self.cpu_single_core = {}
|
||||
self.cpu_multi_core = {}
|
||||
|
|
@ -36,12 +36,26 @@ class Model():
|
|||
{ 'index': [rssi, current, length], ...},
|
||||
}
|
||||
'''
|
||||
self.DEBUG = isDebuging
|
||||
self.logger = None
|
||||
self.voltage = 1
|
||||
self.unit = unit
|
||||
if isDebuging:
|
||||
self.logger = EmptyLogger("Model", printout=True)
|
||||
|
||||
self.DEBUG = isDebugging
|
||||
if self.DEBUG:
|
||||
self.logger = EmptyLogger(
|
||||
"Model", isDebugging=self.DEBUG, printout=True)
|
||||
|
||||
if 'A' in self.unit:
|
||||
tmp = self.unit.replace('A', 'W')
|
||||
self.logger.info(
|
||||
"Will use power instead: {0} -> {1}".format(tmp, unit))
|
||||
self.unit = tmp
|
||||
if 'W' in self.unit:
|
||||
self.using_power = True
|
||||
else:
|
||||
self.using_power = False
|
||||
self.logger.info(
|
||||
"{0} will cause some loss of info like instant power".format(
|
||||
self.unit))
|
||||
|
||||
def load(self, productname, dir="./models/"):
|
||||
self.voltage = getVoltage(productname)
|
||||
|
|
@ -150,11 +164,11 @@ class Model():
|
|||
tmp = current * self.voltage
|
||||
elif 'J' in self.unit:
|
||||
tmp = current * self.voltage * time
|
||||
elif 'A' in self.unit:
|
||||
tmp = current
|
||||
else:
|
||||
self.logger.error(
|
||||
"Unit {0} not supported!".format(self.unit))
|
||||
sys.exit(-1)
|
||||
if 'm' == self.unit[0]:
|
||||
if 'h' == self.unit[-1]:
|
||||
return tmp * time / 3600.0
|
||||
return tmp
|
||||
else:
|
||||
return tmp / 1000.0
|
||||
|
|
@ -195,7 +209,8 @@ class Model():
|
|||
energy = self.get_final_energy(current, time_diff)
|
||||
if self.DEBUG:
|
||||
self.logger.debug(
|
||||
"cpu_energy: {0:.4f}{1}".format(energy, self.unit))
|
||||
"duration: {0:.4f}s, cpu_energy: {1:.4f}{2}".format(
|
||||
time_diff, energy, self.unit))
|
||||
return energy
|
||||
|
||||
def get_lte_prom_energy(self, time_diff, rssi, isTX=True):
|
||||
|
|
|
|||
Loading…
Reference in New Issue