Lines Matching refs:self
319 def __init__(self):
320 self.archargs = 'args_'+platform.machine()
321 self.hostname = platform.node()
322 if(self.hostname == ''):
323 self.hostname = 'localhost'
330 self.rtcpath = rtc
332 self.ansi = True
333 self.testdir = datetime.now().strftime('suspend-%y%m%d-%H%M%S')
336 self.sudouser = os.environ['SUDO_USER']
337 def resetlog(self):
338 self.logmsg = ''
339 self.platinfo = []
340 def vprint(self, msg):
341 self.logmsg += msg+'\n'
342 if self.verbose or msg.startswith('WARNING:'):
344 def signalHandler(self, signum, frame):
345 if not self.result:
347 signame = self.signames[signum] if signum in self.signames else 'UNKNOWN'
349 self.outputResult({'error':msg})
351 def signalHandlerInit(self):
354 self.signames = dict()
359 signal.signal(signum, self.signalHandler)
362 self.signames[signum] = s
363 def rootCheck(self, fatal=True):
364 if(os.access(self.powerfile, os.W_OK)):
369 self.outputResult({'error':msg})
372 def rootUser(self, fatal=False):
378 self.outputResult({'error':msg})
381 def usable(self, file, ishtml=False):
394 def getExec(self, cmd):
409 def setPrecision(self, num):
412 self.timeformat = '%.{0}f'.format(num)
413 def setOutputFolder(self, value):
418 args['hostname'] = args['host'] = self.hostname
419 args['mode'] = self.suspendmode
421 def setOutputFile(self):
422 if self.dmesgfile != '':
423 m = re.match('(?P<name>.*)_dmesg\.txt.*', self.dmesgfile)
425 self.htmlfile = m.group('name')+'.html'
426 if self.ftracefile != '':
427 m = re.match('(?P<name>.*)_ftrace\.txt.*', self.ftracefile)
429 self.htmlfile = m.group('name')+'.html'
430 def systemInfo(self, info):
445 self.sysstamp = '# sysinfo | man:%s | plat:%s | cpu:%s | bios:%s | biosdate:%s | numcpu:%d | memsz:%d | memfr:%d' % \
446 (m, p, c, b, r, self.cpucount, self.memtotal, self.memfree)
447 if self.osversion:
448 self.sysstamp += ' | os:%s' % self.osversion
449 def printSystemInfo(self, fatal=False):
450 self.rootCheck(True)
451 out = dmidecode(self.mempath, fatal)
455 if self.osversion:
456 print(fmt % ('os-version', self.osversion))
459 print(fmt % ('cpucount', ('%d' % self.cpucount)))
460 print(fmt % ('memtotal', ('%d kB' % self.memtotal)))
461 print(fmt % ('memfree', ('%d kB' % self.memfree)))
462 def cpuInfo(self):
463 self.cpucount = 0
468 self.cpucount += 1
474 self.memtotal = int(m.group('sz'))
477 self.memfree = int(m.group('sz'))
482 self.osversion = line[12:].strip().replace('"', '')
483 def initTestOutput(self, name):
484 self.prefix = self.hostname
489 self.teststamp = \
490 '# '+testtime+' '+self.prefix+' '+self.suspendmode+' '+kver
492 if self.gzip:
494 self.dmesgfile = \
495 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_dmesg.txt'+ext
496 self.ftracefile = \
497 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_ftrace.txt'+ext
498 self.htmlfile = \
499 self.testdir+'/'+self.prefix+'_'+self.suspendmode+'.html'
500 if not os.path.isdir(self.testdir):
501 os.makedirs(self.testdir)
502 self.sudoUserchown(self.testdir)
503 def getValueList(self, value):
509 def setDeviceFilter(self, value):
510 self.devicefilter = self.getValueList(value)
511 def setCallgraphFilter(self, value):
512 self.cgfilter = self.getValueList(value)
513 def skipKprobes(self, value):
514 for k in self.getValueList(value):
515 if k in self.tracefuncs:
516 del self.tracefuncs[k]
517 if k in self.dev_tracefuncs:
518 del self.dev_tracefuncs[k]
519 def setCallgraphBlacklist(self, file):
520 self.cgblacklist = self.listFromFile(file)
521 def rtcWakeAlarmOn(self):
522 call('echo 0 > '+self.rtcpath+'/wakealarm', shell=True)
523 nowtime = open(self.rtcpath+'/since_epoch', 'r').read().strip()
529 alarm = nowtime + self.rtcwaketime
530 call('echo %d > %s/wakealarm' % (alarm, self.rtcpath), shell=True)
531 def rtcWakeAlarmOff(self):
532 call('echo 0 > %s/wakealarm' % self.rtcpath, shell=True)
533 def initdmesg(self):
546 self.dmesgstart = float(ktime)
547 def getdmesg(self, testdata):
548 op = self.writeDatafileHeader(self.dmesgfile, testdata)
560 if ktime > self.dmesgstart:
564 def listFromFile(self, file):
573 def addFtraceFilterFunctions(self, file):
574 for i in self.listFromFile(file):
577 self.tracefuncs[i] = dict()
578 def getFtraceFilterFunctions(self, current):
579 self.rootCheck(True)
581 call('cat '+self.tpath+'available_filter_functions', shell=True)
583 master = self.listFromFile(self.tpath+'available_filter_functions')
584 for i in sorted(self.tracefuncs):
585 if 'func' in self.tracefuncs[i]:
586 i = self.tracefuncs[i]['func']
590 print(self.colorText(i))
591 def setFtraceFilterFunctions(self, list):
592 master = self.listFromFile(self.tpath+'available_filter_functions')
601 fp = open(self.tpath+'set_graph_function', 'w')
604 def basicKprobe(self, name):
605 self.kprobes[name] = {'name': name,'func': name,'args': dict(),'format': name}
606 def defaultKprobe(self, name, kdata):
611 if self.archargs in k:
612 k['args'] = k[self.archargs]
616 self.kprobes[name] = k
617 def kprobeColor(self, name):
618 if name not in self.kprobes or 'color' not in self.kprobes[name]:
620 return self.kprobes[name]['color']
621 def kprobeDisplayName(self, name, dataraw):
622 if name not in self.kprobes:
623 self.basicKprobe(name)
634 fmt, args = self.kprobes[name]['format'], self.kprobes[name]['args']
649 def kprobeText(self, kname, kprobe):
658 if self.archargs in kprobe:
659 args = kprobe[self.archargs]
672 def addKprobes(self, output=False):
673 if len(self.kprobes) < 1:
681 linesout = len(self.kprobes)
682 for name in sorted(self.kprobes):
683 res = self.colorText('YES', 32)
684 if not self.testKprobe(name, self.kprobes[name]):
685 res = self.colorText('NO')
688 if name in self.tracefuncs:
690 elif name in self.dev_tracefuncs:
691 if 'ub' in self.dev_tracefuncs[name]:
702 self.kprobes.pop(name)
704 self.fsetVal('', 'kprobe_events')
707 kprobeevents += self.kprobeText(kp, self.kprobes[kp])
708 self.fsetVal(kprobeevents, 'kprobe_events')
710 check = self.fgetVal('kprobe_events')
713 self.fsetVal('1', 'events/kprobes/enable')
714 def testKprobe(self, kname, kprobe):
715 self.fsetVal('0', 'events/kprobes/enable')
716 kprobeevents = self.kprobeText(kname, kprobe)
720 self.fsetVal(kprobeevents, 'kprobe_events')
721 check = self.fgetVal('kprobe_events')
729 def setVal(self, val, file):
740 def fsetVal(self, val, path):
741 if not self.useftrace:
743 return self.setVal(val, self.tpath+path)
744 def getVal(self, file):
755 def fgetVal(self, path):
756 if not self.useftrace:
758 return self.getVal(self.tpath+path)
759 def cleanupFtrace(self):
760 if self.useftrace:
761 self.fsetVal('0', 'events/kprobes/enable')
762 self.fsetVal('', 'kprobe_events')
763 self.fsetVal('1024', 'buffer_size_kb')
764 def setupAllKprobes(self):
765 for name in self.tracefuncs:
766 self.defaultKprobe(name, self.tracefuncs[name])
767 for name in self.dev_tracefuncs:
768 self.defaultKprobe(name, self.dev_tracefuncs[name])
769 def isCallgraphFunc(self, name):
770 if len(self.tracefuncs) < 1 and self.suspendmode == 'command':
772 for i in self.tracefuncs:
773 if 'func' in self.tracefuncs[i]:
774 f = self.tracefuncs[i]['func']
780 def initFtrace(self, quiet=False):
781 if not self.useftrace:
787 self.fsetVal('0', 'tracing_on')
788 self.cleanupFtrace()
790 self.fsetVal('global', 'trace_clock')
791 self.fsetVal('nop', 'current_tracer')
793 cpus = max(1, self.cpucount)
794 if self.bufsize > 0:
795 tgtsize = self.bufsize
796 elif self.usecallgraph or self.usedevsrc:
797 bmax = (1*1024*1024) if self.suspendmode in ['disk', 'command'] \
799 tgtsize = min(self.memfree, bmax)
802 while not self.fsetVal('%d' % (tgtsize // cpus), 'buffer_size_kb'):
806 tgtsize = int(self.fgetVal('buffer_size_kb')) * cpus
808 self.vprint('Setting trace buffers to %d kB (%d kB per cpu)' % (tgtsize, tgtsize/cpus))
810 if(self.usecallgraph):
812 self.fsetVal('function_graph', 'current_tracer')
813 self.fsetVal('', 'set_ftrace_filter')
815 fp = open(self.tpath+'set_ftrace_notrace', 'w')
819 self.fsetVal('print-parent', 'trace_options')
820 self.fsetVal('funcgraph-abstime', 'trace_options')
821 self.fsetVal('funcgraph-cpu', 'trace_options')
822 self.fsetVal('funcgraph-duration', 'trace_options')
823 self.fsetVal('funcgraph-proc', 'trace_options')
824 self.fsetVal('funcgraph-tail', 'trace_options')
825 self.fsetVal('nofuncgraph-overhead', 'trace_options')
826 self.fsetVal('context-info', 'trace_options')
827 self.fsetVal('graph-time', 'trace_options')
828 self.fsetVal('%d' % self.max_graph_depth, 'max_graph_depth')
830 if(self.usetraceevents):
832 for fn in self.tracefuncs:
833 if 'func' in self.tracefuncs[fn]:
834 cf.append(self.tracefuncs[fn]['func'])
837 if self.ftop:
838 self.setFtraceFilterFunctions([self.ftopfunc])
840 self.setFtraceFilterFunctions(cf)
842 elif self.usekprobes:
843 for name in self.tracefuncs:
844 self.defaultKprobe(name, self.tracefuncs[name])
845 if self.usedevsrc:
846 for name in self.dev_tracefuncs:
847 self.defaultKprobe(name, self.dev_tracefuncs[name])
850 self.addKprobes(self.verbose)
851 if(self.usetraceevents):
853 events = iter(self.traceevents)
855 self.fsetVal('1', 'events/power/'+e+'/enable')
857 self.fsetVal('', 'trace')
858 def verifyFtrace(self):
863 tp = self.tpath
864 if(self.usecallgraph):
874 def verifyKprobes(self):
877 tp = self.tpath
882 def colorText(self, str, color=31):
883 if not self.ansi:
886 def writeDatafileHeader(self, filename, testdata):
887 fp = self.openlog(filename, 'w')
888 fp.write('%s\n%s\n# command | %s\n' % (self.teststamp, self.sysstamp, self.cmdline))
903 def sudoUserchown(self, dir):
904 if os.path.exists(dir) and self.sudouser:
906 call(cmd.format(self.sudouser, dir), shell=True)
907 def outputResult(self, testdata, num=0):
908 if not self.result:
913 fp = open(self.result, 'a')
930 self.sudoUserchown(self.result)
931 def configFile(self, file):
940 def openlog(self, filename, mode):
941 isgz = self.gzip
952 def putlog(self, filename, text):
953 with self.openlog(filename, 'a') as fp:
956 def dlog(self, text):
957 if not self.dmesgfile:
959 self.putlog(self.dmesgfile, '# %s\n' % text)
960 def flog(self, text):
961 self.putlog(self.ftracefile, text)
962 def b64unzip(self, data):
968 def b64zip(self, data):
971 def platforminfo(self, cmdafter):
973 if not os.path.exists(self.ftracefile):
978 if self.suspendmode == 'command' and self.testcommand:
979 footer += '# platform-testcmd: %s\n' % (self.testcommand)
984 tf = self.openlog(self.ftracefile, 'r')
986 if tp.stampInfo(line, self):
1046 footer += '# platform-devinfo: %s\n' % self.b64zip(out)
1050 footer += '# platform-%s: %s | %s\n' % (name, cmdline, self.b64zip(info))
1051 self.flog(footer)
1053 def commonPrefix(self, list):
1065 def dictify(self, text, format):
1082 def cmdinfovar(self, arg):
1085 cmd = [self.getExec('ip'), '-4', '-o', '-br', 'addr']
1096 def cmdinfo(self, begin, debug=False):
1099 self.cmd1 = dict()
1100 for cargs in self.infocmds:
1104 args[i] = self.cmdinfovar(args[i][1:-1])
1105 cmdline, cmdpath = ' '.join(args[0:]), self.getExec(args[0])
1108 self.dlog('[%s]' % cmdline)
1116 self.cmd1[name] = self.dictify(info, delta)
1117 elif not debug and delta and name in self.cmd1:
1118 before, after = self.cmd1[name], self.dictify(info, delta)
1120 prefix = self.commonPrefix(list(before.keys()))
1135 def testVal(self, file, fmt='basic', value=''):
1137 for f in self.cfgdef:
1140 fp.write(self.cfgdef[f])
1142 self.cfgdef = dict()
1148 self.cfgdef[file] = m.group('v')
1153 self.cfgdef[file] = m.group('v')
1155 self.cfgdef[file] = fp.read().strip()
1158 def s0ixSupport(self):
1159 if not os.path.exists(self.s0ixres) or not os.path.exists(self.mempowerfile):
1167 def haveTurbostat(self):
1168 if not self.tstat:
1170 cmd = self.getExec('turbostat')
1177 self.vprint(out)
1180 def turbostat(self, s0ixready):
1181 cmd = self.getExec('turbostat')
1183 fullcmd = '%s -q -S echo freeze > %s' % (cmd, self.powerfile)
1197 self.vprint(errmsg)
1198 if not self.verbose:
1201 if self.verbose:
1211 def netfixon(self, net='both'):
1212 cmd = self.getExec('netfix')
1219 def wifiDetails(self, dev):
1229 def checkWifi(self, dev=''):
1240 def pollWifi(self, dev, timeout=10):
1243 w = self.checkWifi(dev)
1246 (self.wifiDetails(dev), max(0, time.time() - start))
1248 return '%s timeout %d' % (self.wifiDetails(dev), timeout)
1249 def errorSummary(self, errinfo, msg):
1254 if self.hostname not in entry['urls']:
1255 entry['urls'][self.hostname] = [self.htmlfile]
1256 elif self.htmlfile not in entry['urls'][self.hostname]:
1257 entry['urls'][self.hostname].append(self.htmlfile)
1277 'urls': {self.hostname: [self.htmlfile]}
1280 def multistat(self, start, idx, finish):
1281 if 'time' in self.multitest:
1282 id = '%d Duration=%dmin' % (idx+1, self.multitest['time'])
1284 id = '%d/%d' % (idx+1, self.multitest['count'])
1286 if 'start' not in self.multitest:
1287 self.multitest['start'] = self.multitest['last'] = t
1288 self.multitest['total'] = 0.0
1291 dt = t - self.multitest['last']
1293 if idx == 0 and self.multitest['delay'] > 0:
1294 self.multitest['total'] += self.multitest['delay']
1297 self.multitest['total'] += dt
1298 self.multitest['last'] = t
1299 avg = self.multitest['total'] / idx
1300 if 'time' in self.multitest:
1304 left = timedelta(seconds=((self.multitest['count'] - idx) * int(avg)))
1307 def multiinit(self, c, d):
1311 self.multitest['run'] = True
1312 self.multitest[sz] = getArgInt('multi: n d (exec count)', c, 1, 1000000, False)
1313 self.multitest['delay'] = getArgInt('multi: n d (delay between tests)', d, 0, 3600, False)
1315 self.multitest[sz] *= 1440
1317 self.multitest[sz] *= 60
1318 def displayControl(self, cmd):
1320 if self.sudouser:
1321 xset = 'sudo -u %s %s' % (self.sudouser, xset)
1329 b4 = self.displayControl('stat')
1332 curr = self.displayControl('stat')
1333 self.vprint('Display Switched: %s -> %s' % (b4, curr))
1335 self.vprint('WARNING: Display failed to change to %s' % cmd)
1337 self.vprint('WARNING: Display failed to change to %s with xset' % cmd)
1350 def setRuntimeSuspend(self, before=True):
1353 if self.rs > 0:
1354 self.rstgt, self.rsval, self.rsdir = 'on', 'auto', 'enabled'
1356 self.rstgt, self.rsval, self.rsdir = 'auto', 'on', 'disabled'
1358 self.rslist = deviceInfo(self.rstgt)
1359 for i in self.rslist:
1360 self.setVal(self.rsval, i)
1361 pprint('runtime suspend %s on all devices (%d changed)' % (self.rsdir, len(self.rslist)))
1366 for i in self.rslist:
1367 self.setVal(self.rstgt, i)
1368 pprint('runtime suspend settings restored on %d devices' % len(self.rslist))
1369 def start(self, pm):
1370 if self.useftrace:
1371 self.dlog('start ftrace tracing')
1372 self.fsetVal('1', 'tracing_on')
1373 if self.useprocmon:
1374 self.dlog('start the process monitor')
1376 def stop(self, pm):
1377 if self.useftrace:
1378 if self.useprocmon:
1379 self.dlog('stop the process monitor')
1381 self.dlog('stop ftrace tracing')
1382 self.fsetVal('0', 'tracing_on')
1399 def __init__(self):
1400 self.syspath = ''
1401 self.altname = ''
1402 self.isasync = True
1403 self.xtraclass = ''
1404 self.xtrainfo = ''
1405 def out(self, dev):
1406 return '%s,%s,%d;' % (dev, self.altname, self.isasync)
1407 def debug(self, dev):
1408 pprint('%s:\n\taltname = %s\n\t async = %s' % (dev, self.altname, self.isasync))
1409 def altName(self, dev):
1410 if not self.altname or self.altname == dev:
1412 return '%s [%s]' % (self.altname, dev)
1413 def xtraClass(self):
1414 if self.xtraclass:
1415 return ' '+self.xtraclass
1416 if not self.isasync:
1419 def xtraInfo(self):
1420 if self.xtraclass:
1421 return ' '+self.xtraclass
1422 if self.isasync:
1431 def __init__(self, nodename, nodedepth):
1432 self.name = nodename
1433 self.children = []
1434 self.depth = nodedepth
1491 def __init__(self, num):
1493 self.start = 0.0 # test start
1494 self.end = 0.0 # test end
1495 self.hwstart = 0 # rtc test start
1496 self.hwend = 0 # rtc test end
1497 self.tSuspended = 0.0 # low-level suspend start
1498 self.tResumed = 0.0 # low-level resume start
1499 self.tKernSus = 0.0 # kernel level suspend start
1500 self.tKernRes = 0.0 # kernel level resume end
1501 self.fwValid = False # is firmware data available
1502 self.fwSuspend = 0 # time spent in firmware suspend
1503 self.fwResume = 0 # time spent in firmware resume
1504 self.html_device_id = 0
1505 self.stamp = 0
1506 self.outfile = ''
1507 self.kerror = False
1508 self.wifi = dict()
1509 self.turbostat = 0
1510 self.enterfail = ''
1511 self.currphase = ''
1512 self.pstl = dict() # process timeline
1513 self.testnumber = num
1514 self.idstr = idchar[num]
1515 self.dmesgtext = [] # dmesg text file in memory
1516 self.dmesg = dict() # root data structure
1517 self.errorinfo = {'suspend':[],'resume':[]}
1518 self.tLow = [] # time spent in low-level suspends (standby/freeze)
1519 self.devpids = []
1520 self.devicegroups = 0
1521 def sortedPhases(self):
1522 return sorted(self.dmesg, key=lambda k:self.dmesg[k]['order'])
1523 def initDevicegroups(self):
1525 for phase in sorted(self.dmesg.keys()):
1529 self.dmesg[pnew] = self.dmesg.pop(phase)
1530 self.devicegroups = []
1531 for phase in self.sortedPhases():
1532 self.devicegroups.append([phase])
1533 def nextPhase(self, phase, offset):
1534 order = self.dmesg[phase]['order'] + offset
1535 for p in self.dmesg:
1536 if self.dmesg[p]['order'] == order:
1539 def lastPhase(self, depth=1):
1540 plist = self.sortedPhases()
1544 def turbostatInfo(self):
1547 for line in self.dmesgtext:
1558 def extractErrorInfo(self):
1559 lf = self.dmesgtext
1560 if len(self.dmesgtext) < 1 and sysvals.dmesgfile:
1573 if t < self.start or t > self.end:
1575 dir = 'suspend' if t < self.tSuspended else 'resume'
1579 for err in self.errlist:
1580 if re.match(self.errlist[err], msg):
1582 self.kerror = True
1587 self.errorinfo[dir].append((type, t, idx1, idx2))
1588 if self.kerror:
1590 if len(self.dmesgtext) < 1 and sysvals.dmesgfile:
1593 def setStart(self, time, msg=''):
1594 self.start = time
1597 self.hwstart = datetime.strptime(msg, sysvals.tmstart)
1599 self.hwstart = 0
1600 def setEnd(self, time, msg=''):
1601 self.end = time
1604 self.hwend = datetime.strptime(msg, sysvals.tmend)
1606 self.hwend = 0
1607 def isTraceEventOutsideDeviceCalls(self, pid, time):
1608 for phase in self.sortedPhases():
1609 list = self.dmesg[phase]['list']
1616 def sourcePhase(self, start):
1617 for phase in self.sortedPhases():
1620 pend = self.dmesg[phase]['end']
1623 return 'resume_complete' if 'resume_complete' in self.dmesg else ''
1624 def sourceDevice(self, phaselist, start, end, pid, type):
1627 list = self.dmesg[phase]['list']
1648 def addDeviceFunctionCall(self, displayname, kprobename, proc, pid, start, end, cdata, rdata):
1650 phases = self.sortedPhases()
1651 tgtdev = self.sourceDevice(phases, start, end, pid, 'device')
1654 if not tgtdev and pid in self.devpids:
1658 tgtdev = self.sourceDevice(phases, start, end, pid, 'thread')
1665 tgtphase = self.sourcePhase(start)
1668 self.newAction(tgtphase, threadname, pid, '', start, end, '', ' kth', '')
1669 return self.addDeviceFunctionCall(displayname, kprobename, proc, pid, start, end, cdata, rdata)
1700 def overflowDevices(self):
1703 for phase in self.sortedPhases():
1704 list = self.dmesg[phase]['list']
1707 if dev['end'] > self.end:
1710 def mergeOverlapDevices(self, devlist):
1714 for phase in self.sortedPhases():
1715 list = self.dmesg[phase]['list']
1727 def usurpTouchingThread(self, name, dev):
1729 for phase in self.sortedPhases():
1730 list = self.dmesg[phase]['list']
1741 def stitchTouchingThreads(self, testlist):
1743 for phase in self.sortedPhases():
1744 list = self.dmesg[phase]['list']
1751 def optimizeDevSrc(self):
1753 for phase in self.sortedPhases():
1754 list = self.dmesg[phase]['list']
1769 def trimTimeVal(self, t, t0, dT, left):
1784 def trimTime(self, t0, dT, left):
1785 self.tSuspended = self.trimTimeVal(self.tSuspended, t0, dT, left)
1786 self.tResumed = self.trimTimeVal(self.tResumed, t0, dT, left)
1787 self.start = self.trimTimeVal(self.start, t0, dT, left)
1788 self.tKernSus = self.trimTimeVal(self.tKernSus, t0, dT, left)
1789 self.tKernRes = self.trimTimeVal(self.tKernRes, t0, dT, left)
1790 self.end = self.trimTimeVal(self.end, t0, dT, left)
1791 for phase in self.sortedPhases():
1792 p = self.dmesg[phase]
1793 p['start'] = self.trimTimeVal(p['start'], t0, dT, left)
1794 p['end'] = self.trimTimeVal(p['end'], t0, dT, left)
1798 d['start'] = self.trimTimeVal(d['start'], t0, dT, left)
1799 d['end'] = self.trimTimeVal(d['end'], t0, dT, left)
1803 cg.start = self.trimTimeVal(cg.start, t0, dT, left)
1804 cg.end = self.trimTimeVal(cg.end, t0, dT, left)
1806 line.time = self.trimTimeVal(line.time, t0, dT, left)
1809 e.time = self.trimTimeVal(e.time, t0, dT, left)
1810 e.end = self.trimTimeVal(e.end, t0, dT, left)
1816 c0 = self.trimTimeVal(c0, t0, dT, left)
1817 cN = self.trimTimeVal(cN, t0, dT, left)
1822 for e in self.errorinfo[dir]:
1824 tm = self.trimTimeVal(tm, t0, dT, left)
1826 self.errorinfo[dir] = list
1827 def trimFreezeTime(self, tZero):
1830 for phase in self.sortedPhases():
1832 tS, tR = self.dmesg[lp]['end'], self.dmesg[phase]['start']
1837 self.trimTime(tS, tL, left)
1838 if 'waking' in self.dmesg[lp]:
1839 tCnt = self.dmesg[lp]['waking'][0]
1840 if self.dmesg[lp]['waking'][1] >= 0.001:
1841 tTry = '%.0f' % (round(self.dmesg[lp]['waking'][1] * 1000))
1843 tTry = '%.3f' % (self.dmesg[lp]['waking'][1] * 1000)
1847 self.tLow.append(text)
1849 def getMemTime(self):
1850 if not self.hwstart or not self.hwend:
1852 stime = (self.tSuspended - self.start) * 1000000
1853 rtime = (self.end - self.tResumed) * 1000000
1854 hws = self.hwstart + timedelta(microseconds=stime)
1855 hwr = self.hwend - timedelta(microseconds=rtime)
1856 self.tLow.append('%.0f'%((hwr - hws).total_seconds() * 1000))
1857 def getTimeValues(self):
1858 s = (self.tSuspended - self.tKernSus) * 1000
1859 r = (self.tKernRes - self.tResumed) * 1000
1861 def setPhase(self, phase, ktime, isbegin, order=-1):
1864 if self.currphase:
1865 if 'resume_machine' not in self.currphase:
1866 sysvals.vprint('WARNING: phase %s failed to end' % self.currphase)
1867 self.dmesg[self.currphase]['end'] = ktime
1868 phases = self.dmesg.keys()
1869 color = self.phasedef[phase]['color']
1874 self.dmesg[phase] = {'list': dict(), 'start': -1.0, 'end': -1.0,
1876 self.dmesg[phase]['start'] = ktime
1877 self.currphase = phase
1880 if phase not in self.currphase:
1881 if self.currphase:
1882 sysvals.vprint('WARNING: %s ended instead of %s, ftrace corruption?' % (phase, self.currphase))
1886 phase = self.currphase
1887 self.dmesg[phase]['end'] = ktime
1888 self.currphase = ''
1890 def sortedDevices(self, phase):
1891 list = self.dmesg[phase]['list']
1893 def fixupInitcalls(self, phase):
1895 phaselist = self.dmesg[phase]['list']
1899 for p in self.sortedPhases():
1900 if self.dmesg[p]['end'] > dev['start']:
1901 dev['end'] = self.dmesg[p]['end']
1904 def deviceFilter(self, devicefilter):
1905 for phase in self.sortedPhases():
1906 list = self.dmesg[phase]['list']
1918 def fixupInitcallsThatDidntReturn(self):
1920 for phase in self.sortedPhases():
1921 self.fixupInitcalls(phase)
1922 def phaseOverlap(self, phases):
1925 for group in self.devicegroups:
1935 self.devicegroups.remove(group)
1936 self.devicegroups.append(newgroup)
1937 def newActionGlobal(self, name, start, end, pid=-1, color=''):
1939 phases = self.sortedPhases()
1945 pstart = self.dmesg[phase]['start']
1946 pend = self.dmesg[phase]['end']
1959 p0start = self.dmesg[phases[0]]['start']
1970 self.phaseOverlap(myphases)
1972 newname = self.newAction(targetphase, name, pid, '', start, end, '', htmlclass, color)
1975 def newAction(self, phase, name, pid, parent, start, end, drv, htmlclass='', color=''):
1977 self.html_device_id += 1
1978 devid = '%s%d' % (self.idstr, self.html_device_id)
1979 list = self.dmesg[phase]['list']
1996 def findDevice(self, phase, name):
1997 list = self.dmesg[phase]['list']
2005 def deviceChildren(self, devname, phase):
2007 list = self.dmesg[phase]['list']
2012 def maxDeviceNameSize(self, phase):
2014 for name in self.dmesg[phase]['list']:
2018 def printDetails(self):
2020 sysvals.vprint(' test start: %f' % self.start)
2021 sysvals.vprint('kernel suspend start: %f' % self.tKernSus)
2023 for phase in self.sortedPhases():
2024 devlist = self.dmesg[phase]['list']
2025 dc, ps, pe = len(devlist), self.dmesg[phase]['start'], self.dmesg[phase]['end']
2026 if not tS and ps >= self.tSuspended:
2027 sysvals.vprint(' machine suspended: %f' % self.tSuspended)
2029 if not tR and ps >= self.tResumed:
2030 sysvals.vprint(' machine resumed: %f' % self.tResumed)
2035 maxname = '%d' % self.maxDeviceNameSize(phase)
2044 sysvals.vprint(' kernel resume end: %f' % self.tKernRes)
2045 sysvals.vprint(' test end: %f' % self.end)
2046 def deviceChildrenAllPhases(self, devname):
2048 for phase in self.sortedPhases():
2049 list = self.deviceChildren(devname, phase)
2054 def masterTopology(self, name, list, depth):
2060 clist = self.deviceChildrenAllPhases(cname)
2061 cnode = self.masterTopology(cname, clist, depth+1)
2064 def printTopology(self, node):
2069 for phase in self.sortedPhases():
2070 list = self.dmesg[phase]['list']
2084 html += self.printTopology(cnode)
2087 def rootDeviceList(self):
2090 for phase in self.sortedPhases():
2091 list = self.dmesg[phase]['list']
2097 for phase in self.sortedPhases():
2098 list = self.dmesg[phase]['list']
2107 def deviceTopology(self):
2108 rootlist = self.rootDeviceList()
2109 master = self.masterTopology('', rootlist, 0)
2110 return self.printTopology(master)
2111 def selectTimelineDevices(self, widfmt, tTotal, mindevlen):
2113 self.tdevlist = dict()
2114 for phase in self.dmesg:
2116 list = self.dmesg[phase]['list']
2122 self.tdevlist[phase] = devlist
2123 def addHorizontalDivider(self, devname, devend):
2125 self.newAction(phase, devname, -2, '', \
2126 self.start, devend, '', ' sec', '')
2127 if phase not in self.tdevlist:
2128 self.tdevlist[phase] = []
2129 self.tdevlist[phase].append(devname)
2130 d = DevItem(0, phase, self.dmesg[phase]['list'][devname])
2132 def addProcessUsageEvent(self, name, times):
2140 if name in self.pstl[t] and self.pstl[t][name] > 0:
2145 cpuexec[key] = min(1.0, float(self.pstl[t][name]) / maxj)
2150 out = self.newActionGlobal(name, start, end, -3)
2153 dev = self.dmesg[phase]['list'][devname]
2155 def createProcessUsageEvents(self):
2159 for t in sorted(self.pstl):
2160 dir = 'sus' if t < self.tSuspended else 'res'
2161 for ps in sorted(self.pstl[t]):
2170 self.addProcessUsageEvent(ps, tdata[dir])
2171 def handleEndMarker(self, time, msg=''):
2172 dm = self.dmesg
2173 self.setEnd(time, msg)
2174 self.initDevicegroups()
2180 np = self.nextPhase('resume_machine', 1)
2184 if self.tKernRes == 0.0:
2185 self.tKernRes = time
2187 if self.tKernSus == 0.0:
2188 self.tKernSus = time
2192 def initcall_debug_call(self, line, quick=False):
2204 def initcall_debug_return(self, line, quick=False):
2216 def debugPrint(self):
2217 for p in self.sortedPhases():
2218 list = self.dmesg[p]['list']
2228 def __init__(self, name, args, caller, ret, start, end, u, proc, pid, color):
2229 self.row = 0
2230 self.count = 1
2231 self.name = name
2232 self.args = args
2233 self.caller = caller
2234 self.ret = ret
2235 self.time = start
2236 self.length = end - start
2237 self.end = end
2238 self.ubiquitous = u
2239 self.proc = proc
2240 self.pid = pid
2241 self.color = color
2242 def title(self):
2244 if self.count > 1:
2245 cnt = '(x%d)' % self.count
2246 l = '%0.3fms' % (self.length * 1000)
2247 if self.ubiquitous:
2249 (self.name, self.args, cnt, self.caller, self.ret, l)
2251 title = '%s(%s) %s%s(%s)' % (self.name, self.args, self.ret, cnt, l)
2253 def text(self):
2254 if self.count > 1:
2255 text = '%s(x%d)' % (self.name, self.count)
2257 text = self.name
2259 def repeat(self, tgt):
2261 dt = self.time - tgt.end
2263 if tgt.caller == self.caller and \
2264 tgt.name == self.name and tgt.args == self.args and \
2265 tgt.proc == self.proc and tgt.pid == self.pid and \
2266 tgt.ret == self.ret and dt >= 0 and \
2268 self.length < sysvals.callloopmaxlen:
2284 def __init__(self, t, m='', d=''):
2285 self.length = 0.0
2286 self.fcall = False
2287 self.freturn = False
2288 self.fevent = False
2289 self.fkprobe = False
2290 self.depth = 0
2291 self.name = ''
2292 self.type = ''
2293 self.time = float(t)
2308 self.name = emm.group('msg')
2309 self.type = emm.group('call')
2311 self.name = msg
2312 km = re.match('^(?P<n>.*)_cal$', self.type)
2314 self.fcall = True
2315 self.fkprobe = True
2316 self.type = km.group('n')
2318 km = re.match('^(?P<n>.*)_ret$', self.type)
2320 self.freturn = True
2321 self.fkprobe = True
2322 self.type = km.group('n')
2324 self.fevent = True
2328 self.length = float(d)/1000000
2333 self.depth = self.getDepth(match.group('d'))
2337 self.freturn = True
2342 self.name = match.group('n').strip()
2345 self.fcall = True
2350 self.name = match.group('n').strip()
2353 self.freturn = True
2356 self.name = match.group('n').strip()
2359 self.name = m
2360 def isCall(self):
2361 return self.fcall and not self.freturn
2362 def isReturn(self):
2363 return self.freturn and not self.fcall
2364 def isLeaf(self):
2365 return self.fcall and self.freturn
2366 def getDepth(self, str):
2368 def debugPrint(self, info=''):
2369 if self.isLeaf():
2370 pprint(' -- %12.6f (depth=%02d): %s(); (%.3f us) %s' % (self.time, \
2371 self.depth, self.name, self.length*1000000, info))
2372 elif self.freturn:
2373 pprint(' -- %12.6f (depth=%02d): %s} (%.3f us) %s' % (self.time, \
2374 self.depth, self.name, self.length*1000000, info))
2376 pprint(' -- %12.6f (depth=%02d): %s() { (%.3f us) %s' % (self.time, \
2377 self.depth, self.name, self.length*1000000, info))
2378 def startMarker(self):
2380 if not self.fevent:
2383 if(self.name.startswith('SUSPEND START')):
2387 if(self.type == 'suspend_resume' and
2388 re.match('suspend_enter\[.*\] begin', self.name)):
2391 def endMarker(self):
2393 if not self.fevent:
2396 if(self.name.startswith('RESUME COMPLETE')):
2400 if(self.type == 'suspend_resume' and
2401 re.match('thaw_processes\[.*\] end', self.name)):
2413 def __init__(self, pid, sv):
2414 self.id = ''
2415 self.invalid = False
2416 self.name = ''
2417 self.partial = False
2418 self.ignore = False
2419 self.start = -1.0
2420 self.end = -1.0
2421 self.list = []
2422 self.depth = 0
2423 self.pid = pid
2424 self.sv = sv
2425 def addLine(self, line):
2427 if(self.invalid):
2432 if(self.depth < 0):
2433 self.invalidate(line)
2436 if self.ignore:
2437 if line.depth > self.depth:
2440 self.list[-1].freturn = True
2441 self.list[-1].length = line.time - self.list[-1].time
2442 self.ignore = False
2443 # if this is a return at self.depth, no more work is needed
2444 if line.depth == self.depth and line.isReturn():
2446 self.end = line.time
2455 if len(self.list) > 0:
2456 last = self.list[-1]
2461 mismatch = prelinedep - self.depth
2462 warning = self.sv.verbose and abs(mismatch) > 1
2467 while prelinedep < self.depth:
2468 self.depth -= 1
2471 last.depth = self.depth
2478 vline.depth = self.depth
2479 vline.name = self.vfname
2481 self.list.append(vline)
2495 while prelinedep > self.depth:
2504 vline.depth = self.depth
2505 vline.name = self.vfname
2507 self.list.append(vline)
2508 self.depth += 1
2510 self.start = vline.time
2524 md = self.sv.max_graph_depth
2527 if (md and self.depth >= md - 1) or (line.name in self.sv.cgblacklist):
2528 self.ignore = True
2530 self.depth += 1
2532 self.depth -= 1
2536 (line.name in self.sv.cgblacklist):
2537 while len(self.list) > 0 and self.list[-1].depth > line.depth:
2538 self.list.pop(-1)
2539 if len(self.list) == 0:
2540 self.invalid = True
2542 self.list[-1].freturn = True
2543 self.list[-1].length = line.time - self.list[-1].time
2544 self.list[-1].name = line.name
2546 if len(self.list) < 1:
2547 self.start = line.time
2550 if mismatch < 0 and self.list[-1].depth == 0 and self.list[-1].freturn:
2551 line = self.list[-1]
2555 self.list.append(line)
2557 if(self.start < 0):
2558 self.start = line.time
2559 self.end = line.time
2561 self.end += line.length
2562 if self.list[0].name == self.vfname:
2563 self.invalid = True
2565 self.partial = True
2568 def invalidate(self, line):
2569 if(len(self.list) > 0):
2570 first = self.list[0]
2571 self.list = []
2572 self.list.append(first)
2573 self.invalid = True
2574 id = 'task %s' % (self.pid)
2575 window = '(%f - %f)' % (self.start, line.time)
2576 if(self.depth < 0):
2582 def slice(self, dev):
2583 minicg = FTraceCallGraph(dev['pid'], self.sv)
2584 minicg.name = self.name
2587 for l in self.list:
2602 def repair(self, enddepth):
2605 last = self.list[-1]
2610 fixed = self.addLine(t)
2612 self.end = last.time
2615 def postProcess(self):
2616 if len(self.list) > 0:
2617 self.name = self.list[0].name
2621 for l in self.list:
2632 if self.sv.verbose:
2639 if cl.name == self.vfname:
2649 if self.sv.verbose:
2653 return self.repair(cnt)
2654 def deviceMatch(self, pid, data):
2661 if(self.name in borderphase):
2662 p = borderphase[self.name]
2667 self.start <= dev['start'] and
2668 self.end >= dev['end']):
2669 cg = self.slice(dev)
2675 if(data.dmesg[p]['start'] <= self.start and
2676 self.start <= data.dmesg[p]['end']):
2681 self.start <= dev['start'] and
2682 self.end >= dev['end']):
2683 dev['ftrace'] = self
2688 def newActionFromFunction(self, data):
2689 name = self.name
2692 fs = self.start
2693 fe = self.end
2698 if(data.dmesg[p]['start'] <= self.start and
2699 self.start < data.dmesg[p]['end']):
2707 data.dmesg[phase]['list'][myname]['ftrace'] = self
2708 def debugPrint(self, info=''):
2710 (self.name, self.pid, self.start, self.end,
2711 (self.end - self.start)*1000000))
2712 for l in self.list:
2725 def __init__(self, test, phase, dev):
2726 self.test = test
2727 self.phase = phase
2728 self.dev = dev
2729 def isa(self, cls):
2730 if 'htmlclass' in self.dev and cls in self.dev['htmlclass']:
2744 def __init__(self, rowheight, scaleheight):
2745 self.html = ''
2746 self.height = 0 # total timeline height
2747 self.scaleH = scaleheight # timescale (top) row height
2748 self.rowH = rowheight # device row height
2749 self.bodyH = 0 # body height
2750 self.rows = 0 # total timeline rows
2751 self.rowlines = dict()
2752 self.rowheight = dict()
2753 def createHeader(self, sv, stamp):
2756 self.html += '<div class="version"><a href="https://01.org/pm-graph">%s v%s</a></div>' \
2759 self.html += '<button id="showtest" class="logbtn btnfmt">log</button>'
2761 self.html += '<button id="showdmesg" class="logbtn btnfmt">dmesg</button>'
2763 self.html += '<button id="showftrace" class="logbtn btnfmt">ftrace</button>'
2765 self.html += headline_stamp.format(stamp['host'], stamp['kernel'],
2770 self.html += headline_sysinfo.format(stamp['man'], stamp['plat'], stamp['cpu'])
2779 def getDeviceRows(self, rawlist):
2820 def getPhaseRows(self, devlist, row=0, sortby='length'):
2840 dev['devrows'] = self.getDeviceRows(dev['src'])
2875 if t not in self.rowlines or t not in self.rowheight:
2876 self.rowlines[t] = dict()
2877 self.rowheight[t] = dict()
2878 if p not in self.rowlines[t] or p not in self.rowheight[t]:
2879 self.rowlines[t][p] = dict()
2880 self.rowheight[t][p] = dict()
2881 rh = self.rowH
2887 self.rowlines[t][p][row] = rowheight
2888 self.rowheight[t][p][row] = rowheight * rh
2890 if(row > self.rows):
2891 self.rows = int(row)
2893 def phaseRowHeight(self, test, phase, row):
2894 return self.rowheight[test][phase][row]
2895 def phaseRowTop(self, test, phase, row):
2897 for i in sorted(self.rowheight[test][phase]):
2900 top += self.rowheight[test][phase][i]
2902 def calcTotalRows(self):
2906 for t in self.rowlines:
2907 for p in self.rowlines[t]:
2909 for i in sorted(self.rowlines[t][p]):
2910 total += self.rowlines[t][p][i]
2913 if total == len(self.rowlines[t][p]):
2915 self.height = self.scaleH + (maxrows*self.rowH)
2916 self.bodyH = self.height - self.scaleH
2919 for i in sorted(self.rowheight[t][p]):
2920 self.rowheight[t][p][i] = float(self.bodyH)/len(self.rowlines[t][p])
2921 def createZoomBox(self, mode='command', testcount=1):
2929 self.html += html_devlist2
2930 self.html += html_devlist1.format('1')
2932 self.html += html_devlist1.format('')
2933 self.html += html_zoombox
2934 self.html += html_timeline.format('dmesg', self.height)
2945 def createTimeScale(self, m0, mMax, tTotal, mode):
2973 self.html += output+'</div>\n'
3006 def __init__(self):
3007 self.stamp = ''
3008 self.sysinfo = ''
3009 self.cmdline = ''
3010 self.testerror = []
3011 self.turbostat = []
3012 self.wifi = []
3013 self.fwdata = []
3014 self.ftrace_line_fmt = self.ftrace_line_fmt_nop
3015 self.cgformat = False
3016 self.data = 0
3017 self.ktemp = dict()
3018 def setTracerType(self, tracer):
3020 self.cgformat = True
3021 self.ftrace_line_fmt = self.ftrace_line_fmt_fg
3023 self.ftrace_line_fmt = self.ftrace_line_fmt_nop
3026 def stampInfo(self, line, sv):
3027 if re.match(self.stampfmt, line):
3028 self.stamp = line
3030 elif re.match(self.sysinfofmt, line):
3031 self.sysinfo = line
3033 elif re.match(self.tstatfmt, line):
3034 self.turbostat.append(line)
3036 elif re.match(self.wififmt, line):
3037 self.wifi.append(line)
3039 elif re.match(self.testerrfmt, line):
3040 self.testerror.append(line)
3042 elif re.match(self.firmwarefmt, line):
3043 self.fwdata.append(line)
3045 elif(re.match(self.devpropfmt, line)):
3046 self.parseDevprops(line, sv)
3048 elif(re.match(self.pinfofmt, line)):
3049 self.parsePlatformInfo(line, sv)
3051 m = re.match(self.cmdlinefmt, line)
3053 self.cmdline = m.group('cmd')
3055 m = re.match(self.tracertypefmt, line)
3057 self.setTracerType(m.group('t'))
3060 def parseStamp(self, data, sv):
3062 m = re.match(self.stampfmt, self.stamp)
3063 if not self.stamp or not m:
3073 if re.match(self.sysinfofmt, self.sysinfo):
3074 for f in self.sysinfo.split('|'):
3084 self.machinesuspend = 'timekeeping_freeze\[.*'
3086 self.machinesuspend = 'machine_suspend\[.*'
3097 sv.cmdline = self.cmdline
3101 if sv.suspendmode == 'mem' and len(self.fwdata) > data.testnumber:
3102 m = re.match(self.firmwarefmt, self.fwdata[data.testnumber])
3108 if len(self.turbostat) > data.testnumber:
3109 m = re.match(self.tstatfmt, self.turbostat[data.testnumber])
3113 if len(self.wifi) > data.testnumber:
3114 m = re.match(self.wififmt, self.wifi[data.testnumber])
3120 if len(self.testerror) > data.testnumber:
3121 m = re.match(self.testerrfmt, self.testerror[data.testnumber])
3124 def devprops(self, data):
3139 def parseDevprops(self, line, sv):
3143 props = self.devprops(line[idx:])
3147 def parsePlatformInfo(self, line, sv):
3148 m = re.match(self.pinfofmt, line)
3153 sv.devprops = self.devprops(sv.b64unzip(info))
3170 def __init__(self, dataobj):
3171 self.data = dataobj
3172 self.ftemp = dict()
3173 self.ttemp = dict()
3177 def __init__(self):
3178 self.proclist = dict()
3179 self.running = False
3180 def procstat(self):
3191 if pid not in self.proclist:
3192 self.proclist[pid] = {'name' : name, 'user' : user, 'kern' : kern}
3194 val = self.proclist[pid]
3205 val = self.proclist[pid]
3206 if len(out[-1]) > self.maxchars:
3216 def processMonitor(self, tid):
3217 while self.running:
3218 self.procstat()
3219 def start(self):
3220 self.thread = Thread(target=self.processMonitor, args=(0,))
3221 self.running = True
3222 self.thread.start()
3223 def stop(self):
3224 self.running = False