mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-04 08:08:54 +00:00
Merge branch 'pm-tools'
* pm-tools: tools: power: pm-graph: Package makefile and man pages tools: power: pm-graph: AnalyzeBoot v2.0 tools: power: pm-graph: AnalyzeSuspend v4.6 tools/power/x86/intel_pstate_tracer: Adjust directory ownership
This commit is contained in:
Rafael J. Wysocki
commit
a1d2fcfd80
6 changed files with 1739 additions and 421 deletions
28
tools/power/pm-graph/Makefile
Normal file
28
tools/power/pm-graph/Makefile
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
PREFIX ?= /usr
|
||||
DESTDIR ?=
|
||||
|
||||
all:
|
||||
@echo "Nothing to build"
|
||||
|
||||
install :
|
||||
install -d $(DESTDIR)$(PREFIX)/lib/pm-graph
|
||||
install analyze_suspend.py $(DESTDIR)$(PREFIX)/lib/pm-graph
|
||||
install analyze_boot.py $(DESTDIR)$(PREFIX)/lib/pm-graph
|
||||
|
||||
ln -s $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_boot.py $(DESTDIR)$(PREFIX)/bin/bootgraph
|
||||
ln -s $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_suspend.py $(DESTDIR)$(PREFIX)/bin/sleepgraph
|
||||
|
||||
install -d $(DESTDIR)$(PREFIX)/share/man/man8
|
||||
install bootgraph.8 $(DESTDIR)$(PREFIX)/share/man/man8
|
||||
install sleepgraph.8 $(DESTDIR)$(PREFIX)/share/man/man8
|
||||
|
||||
uninstall :
|
||||
rm $(DESTDIR)$(PREFIX)/share/man/man8/bootgraph.8
|
||||
rm $(DESTDIR)$(PREFIX)/share/man/man8/sleepgraph.8
|
||||
|
||||
rm $(DESTDIR)$(PREFIX)/bin/bootgraph
|
||||
rm $(DESTDIR)$(PREFIX)/bin/sleepgraph
|
||||
|
||||
rm $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_boot.py
|
||||
rm $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_suspend.py
|
||||
rmdir $(DESTDIR)$(PREFIX)/lib/pm-graph
|
||||
824
tools/power/pm-graph/analyze_boot.py
Executable file
824
tools/power/pm-graph/analyze_boot.py
Executable file
|
|
@ -0,0 +1,824 @@
|
|||
#!/usr/bin/python
|
||||
#
|
||||
# Tool for analyzing boot timing
|
||||
# Copyright (c) 2013, Intel Corporation.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify it
|
||||
# under the terms and conditions of the GNU General Public License,
|
||||
# version 2, as published by the Free Software Foundation.
|
||||
#
|
||||
# This program is distributed in the hope it will be useful, but WITHOUT
|
||||
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
# more details.
|
||||
#
|
||||
# Authors:
|
||||
# Todd Brandt <todd.e.brandt@linux.intel.com>
|
||||
#
|
||||
# Description:
|
||||
# This tool is designed to assist kernel and OS developers in optimizing
|
||||
# their linux stack's boot time. It creates an html representation of
|
||||
# the kernel boot timeline up to the start of the init process.
|
||||
#
|
||||
|
||||
# ----------------- LIBRARIES --------------------
|
||||
|
||||
import sys
|
||||
import time
|
||||
import os
|
||||
import string
|
||||
import re
|
||||
import platform
|
||||
import shutil
|
||||
from datetime import datetime, timedelta
|
||||
from subprocess import call, Popen, PIPE
|
||||
import analyze_suspend as aslib
|
||||
|
||||
# ----------------- CLASSES --------------------
|
||||
|
||||
# Class: SystemValues
|
||||
# Description:
|
||||
# A global, single-instance container used to
|
||||
# store system values and test parameters
|
||||
class SystemValues(aslib.SystemValues):
|
||||
title = 'BootGraph'
|
||||
version = 2.0
|
||||
hostname = 'localhost'
|
||||
testtime = ''
|
||||
kernel = ''
|
||||
dmesgfile = ''
|
||||
ftracefile = ''
|
||||
htmlfile = 'bootgraph.html'
|
||||
outfile = ''
|
||||
phoronix = False
|
||||
addlogs = False
|
||||
useftrace = False
|
||||
usedevsrc = True
|
||||
suspendmode = 'boot'
|
||||
max_graph_depth = 2
|
||||
graph_filter = 'do_one_initcall'
|
||||
reboot = False
|
||||
manual = False
|
||||
iscronjob = False
|
||||
timeformat = '%.6f'
|
||||
def __init__(self):
|
||||
if('LOG_FILE' in os.environ and 'TEST_RESULTS_IDENTIFIER' in os.environ):
|
||||
self.phoronix = True
|
||||
self.addlogs = True
|
||||
self.outfile = os.environ['LOG_FILE']
|
||||
self.htmlfile = os.environ['LOG_FILE']
|
||||
self.hostname = platform.node()
|
||||
self.testtime = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
|
||||
if os.path.exists('/proc/version'):
|
||||
fp = open('/proc/version', 'r')
|
||||
val = fp.read().strip()
|
||||
fp.close()
|
||||
self.kernel = self.kernelVersion(val)
|
||||
else:
|
||||
self.kernel = 'unknown'
|
||||
def kernelVersion(self, msg):
|
||||
return msg.split()[2]
|
||||
def kernelParams(self):
|
||||
cmdline = 'initcall_debug log_buf_len=32M'
|
||||
if self.useftrace:
|
||||
cmdline += ' trace_buf_size=128M trace_clock=global '\
|
||||
'trace_options=nooverwrite,funcgraph-abstime,funcgraph-cpu,'\
|
||||
'funcgraph-duration,funcgraph-proc,funcgraph-tail,'\
|
||||
'nofuncgraph-overhead,context-info,graph-time '\
|
||||
'ftrace=function_graph '\
|
||||
'ftrace_graph_max_depth=%d '\
|
||||
'ftrace_graph_filter=%s' % \
|
||||
(self.max_graph_depth, self.graph_filter)
|
||||
return cmdline
|
||||
def setGraphFilter(self, val):
|
||||
fp = open(self.tpath+'available_filter_functions')
|
||||
master = fp.read().split('\n')
|
||||
fp.close()
|
||||
for i in val.split(','):
|
||||
func = i.strip()
|
||||
if func not in master:
|
||||
doError('function "%s" not available for ftrace' % func)
|
||||
self.graph_filter = val
|
||||
def cronjobCmdString(self):
|
||||
cmdline = '%s -cronjob' % os.path.abspath(sys.argv[0])
|
||||
args = iter(sys.argv[1:])
|
||||
for arg in args:
|
||||
if arg in ['-h', '-v', '-cronjob', '-reboot']:
|
||||
continue
|
||||
elif arg in ['-o', '-dmesg', '-ftrace', '-filter']:
|
||||
args.next()
|
||||
continue
|
||||
cmdline += ' '+arg
|
||||
if self.graph_filter != 'do_one_initcall':
|
||||
cmdline += ' -filter "%s"' % self.graph_filter
|
||||
cmdline += ' -o "%s"' % os.path.abspath(self.htmlfile)
|
||||
return cmdline
|
||||
def manualRebootRequired(self):
|
||||
cmdline = self.kernelParams()
|
||||
print 'To generate a new timeline manually, follow these steps:\n'
|
||||
print '1. Add the CMDLINE string to your kernel command line.'
|
||||
print '2. Reboot the system.'
|
||||
print '3. After reboot, re-run this tool with the same arguments but no command (w/o -reboot or -manual).\n'
|
||||
print 'CMDLINE="%s"' % cmdline
|
||||
sys.exit()
|
||||
|
||||
sysvals = SystemValues()
|
||||
|
||||
# Class: Data
|
||||
# Description:
|
||||
# The primary container for test data.
|
||||
class Data(aslib.Data):
|
||||
dmesg = {} # root data structure
|
||||
start = 0.0 # test start
|
||||
end = 0.0 # test end
|
||||
dmesgtext = [] # dmesg text file in memory
|
||||
testnumber = 0
|
||||
idstr = ''
|
||||
html_device_id = 0
|
||||
valid = False
|
||||
initstart = 0.0
|
||||
boottime = ''
|
||||
phases = ['boot']
|
||||
do_one_initcall = False
|
||||
def __init__(self, num):
|
||||
self.testnumber = num
|
||||
self.idstr = 'a'
|
||||
self.dmesgtext = []
|
||||
self.dmesg = {
|
||||
'boot': {'list': dict(), 'start': -1.0, 'end': -1.0, 'row': 0, 'color': '#dddddd'}
|
||||
}
|
||||
def deviceTopology(self):
|
||||
return ''
|
||||
def newAction(self, phase, name, start, end, ret, ulen):
|
||||
# new device callback for a specific phase
|
||||
self.html_device_id += 1
|
||||
devid = '%s%d' % (self.idstr, self.html_device_id)
|
||||
list = self.dmesg[phase]['list']
|
||||
length = -1.0
|
||||
if(start >= 0 and end >= 0):
|
||||
length = end - start
|
||||
i = 2
|
||||
origname = name
|
||||
while(name in list):
|
||||
name = '%s[%d]' % (origname, i)
|
||||
i += 1
|
||||
list[name] = {'name': name, 'start': start, 'end': end,
|
||||
'pid': 0, 'length': length, 'row': 0, 'id': devid,
|
||||
'ret': ret, 'ulen': ulen }
|
||||
return name
|
||||
def deviceMatch(self, cg):
|
||||
if cg.end - cg.start == 0:
|
||||
return True
|
||||
list = self.dmesg['boot']['list']
|
||||
for devname in list:
|
||||
dev = list[devname]
|
||||
if cg.name == 'do_one_initcall':
|
||||
if(cg.start <= dev['start'] and cg.end >= dev['end'] and dev['length'] > 0):
|
||||
dev['ftrace'] = cg
|
||||
self.do_one_initcall = True
|
||||
return True
|
||||
else:
|
||||
if(cg.start > dev['start'] and cg.end < dev['end']):
|
||||
if 'ftraces' not in dev:
|
||||
dev['ftraces'] = []
|
||||
dev['ftraces'].append(cg)
|
||||
return True
|
||||
return False
|
||||
|
||||
# ----------------- FUNCTIONS --------------------
|
||||
|
||||
# Function: loadKernelLog
|
||||
# Description:
|
||||
# Load a raw kernel log from dmesg
|
||||
def loadKernelLog():
|
||||
data = Data(0)
|
||||
data.dmesg['boot']['start'] = data.start = ktime = 0.0
|
||||
sysvals.stamp = {
|
||||
'time': datetime.now().strftime('%B %d %Y, %I:%M:%S %p'),
|
||||
'host': sysvals.hostname,
|
||||
'mode': 'boot', 'kernel': ''}
|
||||
|
||||
devtemp = dict()
|
||||
if(sysvals.dmesgfile):
|
||||
lf = open(sysvals.dmesgfile, 'r')
|
||||
else:
|
||||
lf = Popen('dmesg', stdout=PIPE).stdout
|
||||
for line in lf:
|
||||
line = line.replace('\r\n', '')
|
||||
idx = line.find('[')
|
||||
if idx > 1:
|
||||
line = line[idx:]
|
||||
m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line)
|
||||
if(not m):
|
||||
continue
|
||||
ktime = float(m.group('ktime'))
|
||||
if(ktime > 120):
|
||||
break
|
||||
msg = m.group('msg')
|
||||
data.end = data.initstart = ktime
|
||||
data.dmesgtext.append(line)
|
||||
if(ktime == 0.0 and re.match('^Linux version .*', msg)):
|
||||
if(not sysvals.stamp['kernel']):
|
||||
sysvals.stamp['kernel'] = sysvals.kernelVersion(msg)
|
||||
continue
|
||||
m = re.match('.* setting system clock to (?P<t>.*) UTC.*', msg)
|
||||
if(m):
|
||||
bt = datetime.strptime(m.group('t'), '%Y-%m-%d %H:%M:%S')
|
||||
bt = bt - timedelta(seconds=int(ktime))
|
||||
data.boottime = bt.strftime('%Y-%m-%d_%H:%M:%S')
|
||||
sysvals.stamp['time'] = bt.strftime('%B %d %Y, %I:%M:%S %p')
|
||||
continue
|
||||
m = re.match('^calling *(?P<f>.*)\+.*', msg)
|
||||
if(m):
|
||||
devtemp[m.group('f')] = ktime
|
||||
continue
|
||||
m = re.match('^initcall *(?P<f>.*)\+.* returned (?P<r>.*) after (?P<t>.*) usecs', msg)
|
||||
if(m):
|
||||
data.valid = True
|
||||
f, r, t = m.group('f', 'r', 't')
|
||||
if(f in devtemp):
|
||||
data.newAction('boot', f, devtemp[f], ktime, int(r), int(t))
|
||||
data.end = ktime
|
||||
del devtemp[f]
|
||||
continue
|
||||
if(re.match('^Freeing unused kernel memory.*', msg)):
|
||||
break
|
||||
|
||||
data.dmesg['boot']['end'] = data.end
|
||||
lf.close()
|
||||
return data
|
||||
|
||||
# Function: loadTraceLog
|
||||
# Description:
|
||||
# Check if trace is available and copy to a temp file
|
||||
def loadTraceLog(data):
|
||||
# load the data to a temp file if none given
|
||||
if not sysvals.ftracefile:
|
||||
lib = aslib.sysvals
|
||||
aslib.rootCheck(True)
|
||||
if not lib.verifyFtrace():
|
||||
doError('ftrace not available')
|
||||
if lib.fgetVal('current_tracer').strip() != 'function_graph':
|
||||
doError('ftrace not configured for a boot callgraph')
|
||||
sysvals.ftracefile = '/tmp/boot_ftrace.%s.txt' % os.getpid()
|
||||
call('cat '+lib.tpath+'trace > '+sysvals.ftracefile, shell=True)
|
||||
if not sysvals.ftracefile:
|
||||
doError('No trace data available')
|
||||
|
||||
# parse the trace log
|
||||
ftemp = dict()
|
||||
tp = aslib.TestProps()
|
||||
tp.setTracerType('function_graph')
|
||||
tf = open(sysvals.ftracefile, 'r')
|
||||
for line in tf:
|
||||
if line[0] == '#':
|
||||
continue
|
||||
m = re.match(tp.ftrace_line_fmt, line.strip())
|
||||
if(not m):
|
||||
continue
|
||||
m_time, m_proc, m_pid, m_msg, m_dur = \
|
||||
m.group('time', 'proc', 'pid', 'msg', 'dur')
|
||||
if float(m_time) > data.end:
|
||||
break
|
||||
if(m_time and m_pid and m_msg):
|
||||
t = aslib.FTraceLine(m_time, m_msg, m_dur)
|
||||
pid = int(m_pid)
|
||||
else:
|
||||
continue
|
||||
if t.fevent or t.fkprobe:
|
||||
continue
|
||||
key = (m_proc, pid)
|
||||
if(key not in ftemp):
|
||||
ftemp[key] = []
|
||||
ftemp[key].append(aslib.FTraceCallGraph(pid))
|
||||
cg = ftemp[key][-1]
|
||||
if(cg.addLine(t)):
|
||||
ftemp[key].append(aslib.FTraceCallGraph(pid))
|
||||
tf.close()
|
||||
|
||||
# add the callgraph data to the device hierarchy
|
||||
for key in ftemp:
|
||||
proc, pid = key
|
||||
for cg in ftemp[key]:
|
||||
if len(cg.list) < 1 or cg.invalid:
|
||||
continue
|
||||
if(not cg.postProcess()):
|
||||
print('Sanity check failed for %s-%d' % (proc, pid))
|
||||
continue
|
||||
# match cg data to devices
|
||||
if not data.deviceMatch(cg):
|
||||
print ' BAD: %s %s-%d [%f - %f]' % (cg.name, proc, pid, cg.start, cg.end)
|
||||
|
||||
# Function: colorForName
|
||||
# Description:
|
||||
# Generate a repeatable color from a list for a given name
|
||||
def colorForName(name):
|
||||
list = [
|
||||
('c1', '#ec9999'),
|
||||
('c2', '#ffc1a6'),
|
||||
('c3', '#fff0a6'),
|
||||
('c4', '#adf199'),
|
||||
('c5', '#9fadea'),
|
||||
('c6', '#a699c1'),
|
||||
('c7', '#ad99b4'),
|
||||
('c8', '#eaffea'),
|
||||
('c9', '#dcecfb'),
|
||||
('c10', '#ffffea')
|
||||
]
|
||||
i = 0
|
||||
total = 0
|
||||
count = len(list)
|
||||
while i < len(name):
|
||||
total += ord(name[i])
|
||||
i += 1
|
||||
return list[total % count]
|
||||
|
||||
def cgOverview(cg, minlen):
|
||||
stats = dict()
|
||||
large = []
|
||||
for l in cg.list:
|
||||
if l.fcall and l.depth == 1:
|
||||
if l.length >= minlen:
|
||||
large.append(l)
|
||||
if l.name not in stats:
|
||||
stats[l.name] = [0, 0.0]
|
||||
stats[l.name][0] += (l.length * 1000.0)
|
||||
stats[l.name][1] += 1
|
||||
return (large, stats)
|
||||
|
||||
# Function: createBootGraph
|
||||
# Description:
|
||||
# Create the output html file from the resident test data
|
||||
# Arguments:
|
||||
# testruns: array of Data objects from parseKernelLog or parseTraceLog
|
||||
# Output:
|
||||
# True if the html file was created, false if it failed
|
||||
def createBootGraph(data, embedded):
|
||||
# html function templates
|
||||
html_srccall = '<div id={6} title="{5}" class="srccall" style="left:{1}%;top:{2}px;height:{3}px;width:{4}%;line-height:{3}px;">{0}</div>\n'
|
||||
html_timetotal = '<table class="time1">\n<tr>'\
|
||||
'<td class="blue">Time from Kernel Boot to start of User Mode: <b>{0} ms</b></td>'\
|
||||
'</tr>\n</table>\n'
|
||||
|
||||
# device timeline
|
||||
devtl = aslib.Timeline(100, 20)
|
||||
|
||||
# write the test title and general info header
|
||||
devtl.createHeader(sysvals, 'noftrace')
|
||||
|
||||
# Generate the header for this timeline
|
||||
t0 = data.start
|
||||
tMax = data.end
|
||||
tTotal = tMax - t0
|
||||
if(tTotal == 0):
|
||||
print('ERROR: No timeline data')
|
||||
return False
|
||||
boot_time = '%.0f'%(tTotal*1000)
|
||||
devtl.html += html_timetotal.format(boot_time)
|
||||
|
||||
# determine the maximum number of rows we need to draw
|
||||
phase = 'boot'
|
||||
list = data.dmesg[phase]['list']
|
||||
devlist = []
|
||||
for devname in list:
|
||||
d = aslib.DevItem(0, phase, list[devname])
|
||||
devlist.append(d)
|
||||
devtl.getPhaseRows(devlist)
|
||||
devtl.calcTotalRows()
|
||||
|
||||
# draw the timeline background
|
||||
devtl.createZoomBox()
|
||||
boot = data.dmesg[phase]
|
||||
length = boot['end']-boot['start']
|
||||
left = '%.3f' % (((boot['start']-t0)*100.0)/tTotal)
|
||||
width = '%.3f' % ((length*100.0)/tTotal)
|
||||
devtl.html += devtl.html_tblock.format(phase, left, width, devtl.scaleH)
|
||||
devtl.html += devtl.html_phase.format('0', '100', \
|
||||
'%.3f'%devtl.scaleH, '%.3f'%devtl.bodyH, \
|
||||
'white', '')
|
||||
|
||||
# draw the device timeline
|
||||
num = 0
|
||||
devstats = dict()
|
||||
for devname in sorted(list):
|
||||
cls, color = colorForName(devname)
|
||||
dev = list[devname]
|
||||
info = '@|%.3f|%.3f|%.3f|%d' % (dev['start']*1000.0, dev['end']*1000.0,
|
||||
dev['ulen']/1000.0, dev['ret'])
|
||||
devstats[dev['id']] = {'info':info}
|
||||
dev['color'] = color
|
||||
height = devtl.phaseRowHeight(0, phase, dev['row'])
|
||||
top = '%.6f' % ((dev['row']*height) + devtl.scaleH)
|
||||
left = '%.6f' % (((dev['start']-t0)*100)/tTotal)
|
||||
width = '%.6f' % (((dev['end']-dev['start'])*100)/tTotal)
|
||||
length = ' (%0.3f ms) ' % ((dev['end']-dev['start'])*1000)
|
||||
devtl.html += devtl.html_device.format(dev['id'],
|
||||
devname+length+'kernel_mode', left, top, '%.3f'%height,
|
||||
width, devname, ' '+cls, '')
|
||||
rowtop = devtl.phaseRowTop(0, phase, dev['row'])
|
||||
height = '%.6f' % (devtl.rowH / 2)
|
||||
top = '%.6f' % (rowtop + devtl.scaleH + (devtl.rowH / 2))
|
||||
if data.do_one_initcall:
|
||||
if('ftrace' not in dev):
|
||||
continue
|
||||
cg = dev['ftrace']
|
||||
large, stats = cgOverview(cg, 0.001)
|
||||
devstats[dev['id']]['fstat'] = stats
|
||||
for l in large:
|
||||
left = '%f' % (((l.time-t0)*100)/tTotal)
|
||||
width = '%f' % (l.length*100/tTotal)
|
||||
title = '%s (%0.3fms)' % (l.name, l.length * 1000.0)
|
||||
devtl.html += html_srccall.format(l.name, left,
|
||||
top, height, width, title, 'x%d'%num)
|
||||
num += 1
|
||||
continue
|
||||
if('ftraces' not in dev):
|
||||
continue
|
||||
for cg in dev['ftraces']:
|
||||
left = '%f' % (((cg.start-t0)*100)/tTotal)
|
||||
width = '%f' % ((cg.end-cg.start)*100/tTotal)
|
||||
cglen = (cg.end - cg.start) * 1000.0
|
||||
title = '%s (%0.3fms)' % (cg.name, cglen)
|
||||
cg.id = 'x%d' % num
|
||||
devtl.html += html_srccall.format(cg.name, left,
|
||||
top, height, width, title, dev['id']+cg.id)
|
||||
num += 1
|
||||
|
||||
# draw the time scale, try to make the number of labels readable
|
||||
devtl.createTimeScale(t0, tMax, tTotal, phase)
|
||||
devtl.html += '</div>\n'
|
||||
|
||||
# timeline is finished
|
||||
devtl.html += '</div>\n</div>\n'
|
||||
|
||||
if(sysvals.outfile == sysvals.htmlfile):
|
||||
hf = open(sysvals.htmlfile, 'a')
|
||||
else:
|
||||
hf = open(sysvals.htmlfile, 'w')
|
||||
|
||||
# add the css if this is not an embedded run
|
||||
extra = '\
|
||||
.c1 {background:rgba(209,0,0,0.4);}\n\
|
||||
.c2 {background:rgba(255,102,34,0.4);}\n\
|
||||
.c3 {background:rgba(255,218,33,0.4);}\n\
|
||||
.c4 {background:rgba(51,221,0,0.4);}\n\
|
||||
.c5 {background:rgba(17,51,204,0.4);}\n\
|
||||
.c6 {background:rgba(34,0,102,0.4);}\n\
|
||||
.c7 {background:rgba(51,0,68,0.4);}\n\
|
||||
.c8 {background:rgba(204,255,204,0.4);}\n\
|
||||
.c9 {background:rgba(169,208,245,0.4);}\n\
|
||||
.c10 {background:rgba(255,255,204,0.4);}\n\
|
||||
.vt {transform:rotate(-60deg);transform-origin:0 0;}\n\
|
||||
table.fstat {table-layout:fixed;padding:150px 15px 0 0;font-size:10px;column-width:30px;}\n\
|
||||
.fstat th {width:55px;}\n\
|
||||
.fstat td {text-align:left;width:35px;}\n\
|
||||
.srccall {position:absolute;font-size:10px;z-index:7;overflow:hidden;color:black;text-align:center;white-space:nowrap;border-radius:5px;border:1px solid black;background:linear-gradient(to bottom right,#CCC,#969696);}\n\
|
||||
.srccall:hover {color:white;font-weight:bold;border:1px solid white;}\n'
|
||||
if(not embedded):
|
||||
aslib.addCSS(hf, sysvals, 1, False, extra)
|
||||
|
||||
# write the device timeline
|
||||
hf.write(devtl.html)
|
||||
|
||||
# add boot specific html
|
||||
statinfo = 'var devstats = {\n'
|
||||
for n in sorted(devstats):
|
||||
statinfo += '\t"%s": [\n\t\t"%s",\n' % (n, devstats[n]['info'])
|
||||
if 'fstat' in devstats[n]:
|
||||
funcs = devstats[n]['fstat']
|
||||
for f in sorted(funcs, key=funcs.get, reverse=True):
|
||||
if funcs[f][0] < 0.01 and len(funcs) > 10:
|
||||
break
|
||||
statinfo += '\t\t"%f|%s|%d",\n' % (funcs[f][0], f, funcs[f][1])
|
||||
statinfo += '\t],\n'
|
||||
statinfo += '};\n'
|
||||
html = \
|
||||
'<div id="devicedetailtitle"></div>\n'\
|
||||
'<div id="devicedetail" style="display:none;">\n'\
|
||||
'<div id="devicedetail0">\n'\
|
||||
'<div id="kernel_mode" class="phaselet" style="left:0%;width:100%;background:#DDDDDD"></div>\n'\
|
||||
'</div>\n</div>\n'\
|
||||
'<script type="text/javascript">\n'+statinfo+\
|
||||
'</script>\n'
|
||||
hf.write(html)
|
||||
|
||||
# add the callgraph html
|
||||
if(sysvals.usecallgraph):
|
||||
aslib.addCallgraphs(sysvals, hf, data)
|
||||
|
||||
# add the dmesg log as a hidden div
|
||||
if sysvals.addlogs:
|
||||
hf.write('<div id="dmesglog" style="display:none;">\n')
|
||||
for line in data.dmesgtext:
|
||||
line = line.replace('<', '<').replace('>', '>')
|
||||
hf.write(line)
|
||||
hf.write('</div>\n')
|
||||
|
||||
if(not embedded):
|
||||
# write the footer and close
|
||||
aslib.addScriptCode(hf, [data])
|
||||
hf.write('</body>\n</html>\n')
|
||||
else:
|
||||
# embedded out will be loaded in a page, skip the js
|
||||
hf.write('<div id=bounds style=display:none>%f,%f</div>' % \
|
||||
(data.start*1000, data.initstart*1000))
|
||||
hf.close()
|
||||
return True
|
||||
|
||||
# Function: updateCron
|
||||
# Description:
|
||||
# (restore=False) Set the tool to run automatically on reboot
|
||||
# (restore=True) Restore the original crontab
|
||||
def updateCron(restore=False):
|
||||
if not restore:
|
||||
sysvals.rootUser(True)
|
||||
crondir = '/var/spool/cron/crontabs/'
|
||||
cronfile = crondir+'root'
|
||||
backfile = crondir+'root-analyze_boot-backup'
|
||||
if not os.path.exists(crondir):
|
||||
doError('%s not found' % crondir)
|
||||
out = Popen(['which', 'crontab'], stdout=PIPE).stdout.read()
|
||||
if not out:
|
||||
doError('crontab not found')
|
||||
# on restore: move the backup cron back into place
|
||||
if restore:
|
||||
if os.path.exists(backfile):
|
||||
shutil.move(backfile, cronfile)
|
||||
return
|
||||
# backup current cron and install new one with reboot
|
||||
if os.path.exists(cronfile):
|
||||
shutil.move(cronfile, backfile)
|
||||
else:
|
||||
fp = open(backfile, 'w')
|
||||
fp.close()
|
||||
res = -1
|
||||
try:
|
||||
fp = open(backfile, 'r')
|
||||
op = open(cronfile, 'w')
|
||||
for line in fp:
|
||||
if '@reboot' not in line:
|
||||
op.write(line)
|
||||
continue
|
||||
fp.close()
|
||||
op.write('@reboot python %s\n' % sysvals.cronjobCmdString())
|
||||
op.close()
|
||||
res = call('crontab %s' % cronfile, shell=True)
|
||||
except Exception, e:
|
||||
print 'Exception: %s' % str(e)
|
||||
shutil.move(backfile, cronfile)
|
||||
res = -1
|
||||
if res != 0:
|
||||
doError('crontab failed')
|
||||
|
||||
# Function: updateGrub
|
||||
# Description:
|
||||
# update grub.cfg for all kernels with our parameters
|
||||
def updateGrub(restore=False):
|
||||
# call update-grub on restore
|
||||
if restore:
|
||||
try:
|
||||
call(['update-grub'], stderr=PIPE, stdout=PIPE,
|
||||
env={'PATH': '.:/sbin:/usr/sbin:/usr/bin:/sbin:/bin'})
|
||||
except Exception, e:
|
||||
print 'Exception: %s\n' % str(e)
|
||||
return
|
||||
# verify we can do this
|
||||
sysvals.rootUser(True)
|
||||
grubfile = '/etc/default/grub'
|
||||
if not os.path.exists(grubfile):
|
||||
print 'ERROR: Unable to set the kernel parameters via grub.\n'
|
||||
sysvals.manualRebootRequired()
|
||||
out = Popen(['which', 'update-grub'], stdout=PIPE).stdout.read()
|
||||
if not out:
|
||||
print 'ERROR: Unable to set the kernel parameters via grub.\n'
|
||||
sysvals.manualRebootRequired()
|
||||
|
||||
# extract the option and create a grub config without it
|
||||
tgtopt = 'GRUB_CMDLINE_LINUX_DEFAULT'
|
||||
cmdline = ''
|
||||
tempfile = '/etc/default/grub.analyze_boot'
|
||||
shutil.move(grubfile, tempfile)
|
||||
res = -1
|
||||
try:
|
||||
fp = open(tempfile, 'r')
|
||||
op = open(grubfile, 'w')
|
||||
cont = False
|
||||
for line in fp:
|
||||
line = line.strip()
|
||||
if len(line) == 0 or line[0] == '#':
|
||||
continue
|
||||
opt = line.split('=')[0].strip()
|
||||
if opt == tgtopt:
|
||||
cmdline = line.split('=', 1)[1].strip('\\')
|
||||
if line[-1] == '\\':
|
||||
cont = True
|
||||
elif cont:
|
||||
cmdline += line.strip('\\')
|
||||
if line[-1] != '\\':
|
||||
cont = False
|
||||
else:
|
||||
op.write('%s\n' % line)
|
||||
fp.close()
|
||||
# if the target option value is in quotes, strip them
|
||||
sp = '"'
|
||||
val = cmdline.strip()
|
||||
if val[0] == '\'' or val[0] == '"':
|
||||
sp = val[0]
|
||||
val = val.strip(sp)
|
||||
cmdline = val
|
||||
# append our cmd line options
|
||||
if len(cmdline) > 0:
|
||||
cmdline += ' '
|
||||
cmdline += sysvals.kernelParams()
|
||||
# write out the updated target option
|
||||
op.write('\n%s=%s%s%s\n' % (tgtopt, sp, cmdline, sp))
|
||||
op.close()
|
||||
res = call('update-grub')
|
||||
os.remove(grubfile)
|
||||
except Exception, e:
|
||||
print 'Exception: %s' % str(e)
|
||||
res = -1
|
||||
# cleanup
|
||||
shutil.move(tempfile, grubfile)
|
||||
if res != 0:
|
||||
doError('update-grub failed')
|
||||
|
||||
# Function: doError
|
||||
# Description:
|
||||
# generic error function for catastrphic failures
|
||||
# Arguments:
|
||||
# msg: the error message to print
|
||||
# help: True if printHelp should be called after, False otherwise
|
||||
def doError(msg, help=False):
|
||||
if help == True:
|
||||
printHelp()
|
||||
print 'ERROR: %s\n' % msg
|
||||
sys.exit()
|
||||
|
||||
# Function: printHelp
|
||||
# Description:
|
||||
# print out the help text
|
||||
def printHelp():
|
||||
print('')
|
||||
print('%s v%.1f' % (sysvals.title, sysvals.version))
|
||||
print('Usage: bootgraph <options> <command>')
|
||||
print('')
|
||||
print('Description:')
|
||||
print(' This tool reads in a dmesg log of linux kernel boot and')
|
||||
print(' creates an html representation of the boot timeline up to')
|
||||
print(' the start of the init process.')
|
||||
print('')
|
||||
print(' If no specific command is given the tool reads the current dmesg')
|
||||
print(' and/or ftrace log and outputs bootgraph.html')
|
||||
print('')
|
||||
print('Options:')
|
||||
print(' -h Print this help text')
|
||||
print(' -v Print the current tool version')
|
||||
print(' -addlogs Add the dmesg log to the html output')
|
||||
print(' -o file Html timeline name (default: bootgraph.html)')
|
||||
print(' [advanced]')
|
||||
print(' -f Use ftrace to add function detail (default: disabled)')
|
||||
print(' -callgraph Add callgraph detail, can be very large (default: disabled)')
|
||||
print(' -maxdepth N limit the callgraph data to N call levels (default: 2)')
|
||||
print(' -mincg ms Discard all callgraphs shorter than ms milliseconds (e.g. 0.001 for us)')
|
||||
print(' -timeprec N Number of significant digits in timestamps (0:S, 3:ms, [6:us])')
|
||||
print(' -expandcg pre-expand the callgraph data in the html output (default: disabled)')
|
||||
print(' -filter list Limit ftrace to comma-delimited list of functions (default: do_one_initcall)')
|
||||
print(' [commands]')
|
||||
print(' -reboot Reboot the machine automatically and generate a new timeline')
|
||||
print(' -manual Show the requirements to generate a new timeline manually')
|
||||
print(' -dmesg file Load a stored dmesg file (used with -ftrace)')
|
||||
print(' -ftrace file Load a stored ftrace file (used with -dmesg)')
|
||||
print(' -flistall Print all functions capable of being captured in ftrace')
|
||||
print('')
|
||||
return True
|
||||
|
||||
# ----------------- MAIN --------------------
|
||||
# exec start (skipped if script is loaded as library)
|
||||
if __name__ == '__main__':
|
||||
# loop through the command line arguments
|
||||
cmd = ''
|
||||
simplecmds = ['-updategrub', '-flistall']
|
||||
args = iter(sys.argv[1:])
|
||||
for arg in args:
|
||||
if(arg == '-h'):
|
||||
printHelp()
|
||||
sys.exit()
|
||||
elif(arg == '-v'):
|
||||
print("Version %.1f" % sysvals.version)
|
||||
sys.exit()
|
||||
elif(arg in simplecmds):
|
||||
cmd = arg[1:]
|
||||
elif(arg == '-f'):
|
||||
sysvals.useftrace = True
|
||||
elif(arg == '-callgraph'):
|
||||
sysvals.useftrace = True
|
||||
sysvals.usecallgraph = True
|
||||
elif(arg == '-mincg'):
|
||||
sysvals.mincglen = aslib.getArgFloat('-mincg', args, 0.0, 10000.0)
|
||||
elif(arg == '-timeprec'):
|
||||
sysvals.setPrecision(aslib.getArgInt('-timeprec', args, 0, 6))
|
||||
elif(arg == '-maxdepth'):
|
||||
sysvals.max_graph_depth = aslib.getArgInt('-maxdepth', args, 0, 1000)
|
||||
elif(arg == '-filter'):
|
||||
try:
|
||||
val = args.next()
|
||||
except:
|
||||
doError('No filter functions supplied', True)
|
||||
aslib.rootCheck(True)
|
||||
sysvals.setGraphFilter(val)
|
||||
elif(arg == '-ftrace'):
|
||||
try:
|
||||
val = args.next()
|
||||
except:
|
||||
doError('No ftrace file supplied', True)
|
||||
if(os.path.exists(val) == False):
|
||||
doError('%s does not exist' % val)
|
||||
sysvals.ftracefile = val
|
||||
elif(arg == '-addlogs'):
|
||||
sysvals.addlogs = True
|
||||
elif(arg == '-expandcg'):
|
||||
sysvals.cgexp = True
|
||||
elif(arg == '-dmesg'):
|
||||
try:
|
||||
val = args.next()
|
||||
except:
|
||||
doError('No dmesg file supplied', True)
|
||||
if(os.path.exists(val) == False):
|
||||
doError('%s does not exist' % val)
|
||||
if(sysvals.htmlfile == val or sysvals.outfile == val):
|
||||
doError('Output filename collision')
|
||||
sysvals.dmesgfile = val
|
||||
elif(arg == '-o'):
|
||||
try:
|
||||
val = args.next()
|
||||
except:
|
||||
doError('No HTML filename supplied', True)
|
||||
if(sysvals.dmesgfile == val or sysvals.ftracefile == val):
|
||||
doError('Output filename collision')
|
||||
sysvals.htmlfile = val
|
||||
elif(arg == '-reboot'):
|
||||
if sysvals.iscronjob:
|
||||
doError('-reboot and -cronjob are incompatible')
|
||||
sysvals.reboot = True
|
||||
elif(arg == '-manual'):
|
||||
sysvals.reboot = True
|
||||
sysvals.manual = True
|
||||
# remaining options are only for cron job use
|
||||
elif(arg == '-cronjob'):
|
||||
sysvals.iscronjob = True
|
||||
if sysvals.reboot:
|
||||
doError('-reboot and -cronjob are incompatible')
|
||||
else:
|
||||
doError('Invalid argument: '+arg, True)
|
||||
|
||||
if cmd != '':
|
||||
if cmd == 'updategrub':
|
||||
updateGrub()
|
||||
elif cmd == 'flistall':
|
||||
sysvals.getFtraceFilterFunctions(False)
|
||||
sys.exit()
|
||||
|
||||
# update grub, setup a cronjob, and reboot
|
||||
if sysvals.reboot:
|
||||
if not sysvals.manual:
|
||||
updateGrub()
|
||||
updateCron()
|
||||
call('reboot')
|
||||
else:
|
||||
sysvals.manualRebootRequired()
|
||||
sys.exit()
|
||||
|
||||
# disable the cronjob
|
||||
if sysvals.iscronjob:
|
||||
updateCron(True)
|
||||
updateGrub(True)
|
||||
|
||||
data = loadKernelLog()
|
||||
if sysvals.useftrace:
|
||||
loadTraceLog(data)
|
||||
if sysvals.iscronjob:
|
||||
try:
|
||||
sysvals.fsetVal('0', 'tracing_on')
|
||||
except:
|
||||
pass
|
||||
|
||||
if(sysvals.outfile and sysvals.phoronix):
|
||||
fp = open(sysvals.outfile, 'w')
|
||||
fp.write('pass %s initstart %.3f end %.3f boot %s\n' %
|
||||
(data.valid, data.initstart*1000, data.end*1000, data.boottime))
|
||||
fp.close()
|
||||
if(not data.valid):
|
||||
if sysvals.dmesgfile:
|
||||
doError('No initcall data found in %s' % sysvals.dmesgfile)
|
||||
else:
|
||||
doError('No initcall data found, is initcall_debug enabled?')
|
||||
|
||||
print(' Host: %s' % sysvals.hostname)
|
||||
print(' Test time: %s' % sysvals.testtime)
|
||||
print(' Boot time: %s' % data.boottime)
|
||||
print('Kernel Version: %s' % sysvals.kernel)
|
||||
print(' Kernel start: %.3f' % (data.start * 1000))
|
||||
print(' init start: %.3f' % (data.initstart * 1000))
|
||||
|
||||
createBootGraph(data, sysvals.phoronix)
|
||||
File diff suppressed because it is too large
Load diff
132
tools/power/pm-graph/bootgraph.8
Normal file
132
tools/power/pm-graph/bootgraph.8
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
.TH BOOTGRAPH 8
|
||||
.SH NAME
|
||||
bootgraph \- Kernel boot timing analysis
|
||||
.SH SYNOPSIS
|
||||
.ft B
|
||||
.B bootgraph
|
||||
.RB [ OPTIONS ]
|
||||
.RB [ COMMAND ]
|
||||
.SH DESCRIPTION
|
||||
\fBbootgraph \fP reads the dmesg log from kernel boot and
|
||||
creates an html representation of the initcall timeline up to the start
|
||||
of the init process.
|
||||
.PP
|
||||
If no specific command is given, the tool reads the current dmesg log and
|
||||
outputs bootgraph.html.
|
||||
.PP
|
||||
The tool can also augment the timeline with ftrace data on custom target
|
||||
functions as well as full trace callgraphs.
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
\fB-h\fR
|
||||
Print this help text
|
||||
.TP
|
||||
\fB-v\fR
|
||||
Print the current tool version
|
||||
.TP
|
||||
\fB-addlogs\fR
|
||||
Add the dmesg log to the html output. It will be viewable by
|
||||
clicking a button in the timeline.
|
||||
.TP
|
||||
\fB-o \fIfile\fR
|
||||
Override the HTML output filename (default: bootgraph.html)
|
||||
.SS "Ftrace Debug"
|
||||
.TP
|
||||
\fB-f\fR
|
||||
Use ftrace to add function detail (default: disabled)
|
||||
.TP
|
||||
\fB-callgraph\fR
|
||||
Use ftrace to create initcall callgraphs (default: disabled). If -filter
|
||||
is not used there will be one callgraph per initcall. This can produce
|
||||
very large outputs, i.e. 10MB - 100MB.
|
||||
.TP
|
||||
\fB-maxdepth \fIlevel\fR
|
||||
limit the callgraph trace depth to \fIlevel\fR (default: 2). This is
|
||||
the best way to limit the output size when using -callgraph.
|
||||
.TP
|
||||
\fB-mincg \fIt\fR
|
||||
Discard all callgraphs shorter than \fIt\fR milliseconds (default: 0=all).
|
||||
This reduces the html file size as there can be many tiny callgraphs
|
||||
which are barely visible in the timeline.
|
||||
The value is a float: e.g. 0.001 represents 1 us.
|
||||
.TP
|
||||
\fB-timeprec \fIn\fR
|
||||
Number of significant digits in timestamps (0:S, 3:ms, [6:us])
|
||||
.TP
|
||||
\fB-expandcg\fR
|
||||
pre-expand the callgraph data in the html output (default: disabled)
|
||||
.TP
|
||||
\fB-filter \fI"func1,func2,..."\fR
|
||||
Instead of tracing each initcall, trace a custom list of functions (default: do_one_initcall)
|
||||
|
||||
.SH COMMANDS
|
||||
.TP
|
||||
\fB-reboot\fR
|
||||
Reboot the machine and generate a new timeline automatically. Works in 4 steps.
|
||||
1. updates grub with the required kernel parameters
|
||||
2. installs a cron job which re-runs the tool after reboot
|
||||
3. reboots the system
|
||||
4. after startup, extracts the data and generates the timeline
|
||||
.TP
|
||||
\fB-manual\fR
|
||||
Show the requirements to generate a new timeline manually. Requires 3 steps.
|
||||
1. append the string to the kernel command line via your native boot manager.
|
||||
2. reboot the system
|
||||
3. after startup, re-run the tool with the same arguments and no command
|
||||
.TP
|
||||
\fB-dmesg \fIfile\fR
|
||||
Create HTML output from an existing dmesg file.
|
||||
.TP
|
||||
\fB-ftrace \fIfile\fR
|
||||
Create HTML output from an existing ftrace file (used with -dmesg).
|
||||
.TP
|
||||
\fB-flistall\fR
|
||||
Print all ftrace functions capable of being captured. These are all the
|
||||
possible values you can add to trace via the -filter argument.
|
||||
|
||||
.SH EXAMPLES
|
||||
Create a timeline using the current dmesg log.
|
||||
.IP
|
||||
\f(CW$ bootgraph\fR
|
||||
.PP
|
||||
Create a timeline using the current dmesg and ftrace log.
|
||||
.IP
|
||||
\f(CW$ bootgraph -callgraph\fR
|
||||
.PP
|
||||
Create a timeline using the current dmesg, add the log to the html and change the name.
|
||||
.IP
|
||||
\f(CW$ bootgraph -addlogs -o myboot.html\fR
|
||||
.PP
|
||||
Capture a new boot timeline by automatically rebooting the machine.
|
||||
.IP
|
||||
\f(CW$ sudo bootgraph -reboot -addlogs -o latestboot.html\fR
|
||||
.PP
|
||||
Capture a new boot timeline with function trace data.
|
||||
.IP
|
||||
\f(CW$ sudo bootgraph -reboot -f\fR
|
||||
.PP
|
||||
Capture a new boot timeline with trace & callgraph data. Skip callgraphs smaller than 5ms.
|
||||
.IP
|
||||
\f(CW$ sudo bootgraph -reboot -callgraph -mincg 5\fR
|
||||
.PP
|
||||
Capture a new boot timeline with callgraph data over custom functions.
|
||||
.IP
|
||||
\f(CW$ sudo bootgraph -reboot -callgraph -filter "acpi_ps_parse_aml,msleep"\fR
|
||||
.PP
|
||||
Capture a brand new boot timeline with manual reboot.
|
||||
.IP
|
||||
\f(CW$ sudo bootgraph -callgraph -manual\fR
|
||||
.IP
|
||||
\f(CW$ vi /etc/default/grub # add the CMDLINE string to your kernel params\fR
|
||||
.IP
|
||||
\f(CW$ sudo reboot # reboot the machine\fR
|
||||
.IP
|
||||
\f(CW$ sudo bootgraph -callgraph # re-run the tool after restart\fR
|
||||
.PP
|
||||
|
||||
.SH "SEE ALSO"
|
||||
dmesg(1), update-grub(8), crontab(1), reboot(8)
|
||||
.PP
|
||||
.SH AUTHOR
|
||||
.nf
|
||||
Written by Todd Brandt <todd.e.brandt@linux.intel.com>
|
||||
243
tools/power/pm-graph/sleepgraph.8
Normal file
243
tools/power/pm-graph/sleepgraph.8
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
.TH SLEEPGRAPH 8
|
||||
.SH NAME
|
||||
sleepgraph \- Suspend/Resume timing analysis
|
||||
.SH SYNOPSIS
|
||||
.ft B
|
||||
.B sleepgraph
|
||||
.RB [ OPTIONS ]
|
||||
.RB [ COMMAND ]
|
||||
.SH DESCRIPTION
|
||||
\fBsleepgraph \fP is designed to assist kernel and OS developers
|
||||
in optimizing their linux stack's suspend/resume time. Using a kernel
|
||||
image built with a few extra options enabled, the tool will execute a
|
||||
suspend and capture dmesg and ftrace data until resume is complete.
|
||||
This data is transformed into a device timeline and an optional
|
||||
callgraph to give a detailed view of which devices/subsystems are
|
||||
taking the most time in suspend/resume.
|
||||
.PP
|
||||
If no specific command is given, the default behavior is to initiate
|
||||
a suspend/resume.
|
||||
.PP
|
||||
Generates output files in subdirectory: suspend-yymmdd-HHMMSS
|
||||
html timeline : <hostname>_<mode>.html
|
||||
raw dmesg file : <hostname>_<mode>_dmesg.txt
|
||||
raw ftrace file : <hostname>_<mode>_ftrace.txt
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
\fB-h\fR
|
||||
Print the help text.
|
||||
.TP
|
||||
\fB-v\fR
|
||||
Print the current tool version.
|
||||
.TP
|
||||
\fB-verbose\fR
|
||||
Print extra information during execution and analysis.
|
||||
.TP
|
||||
\fB-config \fIfile\fR
|
||||
Pull arguments and config options from a file.
|
||||
.TP
|
||||
\fB-m \fImode\fR
|
||||
Mode to initiate for suspend e.g. standby, freeze, mem (default: mem).
|
||||
.TP
|
||||
\fB-o \fIsubdir\fR
|
||||
Override the output subdirectory. Use {date}, {time}, {hostname} for current values.
|
||||
.sp
|
||||
e.g. suspend-{hostname}-{date}-{time}
|
||||
.TP
|
||||
\fB-rtcwake \fIt\fR | off
|
||||
Use rtcwake to autoresume after \fIt\fR seconds (default: 15). Set t to "off" to
|
||||
disable rtcwake and require a user keypress to resume.
|
||||
.TP
|
||||
\fB-addlogs\fR
|
||||
Add the dmesg and ftrace logs to the html output. They will be viewable by
|
||||
clicking buttons in the timeline.
|
||||
|
||||
.SS "Advanced"
|
||||
.TP
|
||||
\fB-cmd \fIstr\fR
|
||||
Run the timeline over a custom suspend command, e.g. pm-suspend. By default
|
||||
the tool forces suspend via /sys/power/state so this allows testing over
|
||||
an OS's official suspend method. The output file will change to
|
||||
hostname_command.html and will autodetect which suspend mode was triggered.
|
||||
.TP
|
||||
\fB-filter \fI"d1,d2,..."\fR
|
||||
Filter out all but these device callbacks. These strings can be device names
|
||||
or module names. e.g. 0000:00:02.0, ata5, i915, usb, etc.
|
||||
.TP
|
||||
\fB-mindev \fIt\fR
|
||||
Discard all device callbacks shorter than \fIt\fR milliseconds (default: 0.0).
|
||||
This reduces the html file size as there can be many tiny callbacks which are barely
|
||||
visible. The value is a float: e.g. 0.001 represents 1 us.
|
||||
.TP
|
||||
\fB-proc\fR
|
||||
Add usermode process info into the timeline (default: disabled).
|
||||
.TP
|
||||
\fB-dev\fR
|
||||
Add kernel source calls and threads to the timeline (default: disabled).
|
||||
.TP
|
||||
\fB-x2\fR
|
||||
Run two suspend/resumes back to back (default: disabled).
|
||||
.TP
|
||||
\fB-x2delay \fIt\fR
|
||||
Include \fIt\fR ms delay between multiple test runs (default: 0 ms).
|
||||
.TP
|
||||
\fB-predelay \fIt\fR
|
||||
Include \fIt\fR ms delay before 1st suspend (default: 0 ms).
|
||||
.TP
|
||||
\fB-postdelay \fIt\fR
|
||||
Include \fIt\fR ms delay after last resume (default: 0 ms).
|
||||
.TP
|
||||
\fB-multi \fIn d\fR
|
||||
Execute \fIn\fR consecutive tests at \fId\fR seconds intervals. The outputs will
|
||||
be created in a new subdirectory with a summary page: suspend-xN-{date}-{time}.
|
||||
|
||||
.SS "Ftrace Debug"
|
||||
.TP
|
||||
\fB-f\fR
|
||||
Use ftrace to create device callgraphs (default: disabled). This can produce
|
||||
very large outputs, i.e. 10MB - 100MB.
|
||||
.TP
|
||||
\fB-maxdepth \fIlevel\fR
|
||||
limit the callgraph trace depth to \fIlevel\fR (default: 0=all). This is
|
||||
the best way to limit the output size when using callgraphs via -f.
|
||||
.TP
|
||||
\fB-expandcg\fR
|
||||
pre-expand the callgraph data in the html output (default: disabled)
|
||||
.TP
|
||||
\fB-fadd \fIfile\fR
|
||||
Add functions to be graphed in the timeline from a list in a text file
|
||||
.TP
|
||||
\fB-mincg \fIt\fR
|
||||
Discard all callgraphs shorter than \fIt\fR milliseconds (default: 0.0).
|
||||
This reduces the html file size as there can be many tiny callgraphs
|
||||
which are barely visible in the timeline.
|
||||
The value is a float: e.g. 0.001 represents 1 us.
|
||||
.TP
|
||||
\fB-cgphase \fIp\fR
|
||||
Only show callgraph data for phase \fIp\fR (e.g. suspend_late).
|
||||
.TP
|
||||
\fB-cgtest \fIn\fR
|
||||
In an x2 run, only show callgraph data for test \fIn\fR (e.g. 0 or 1).
|
||||
.TP
|
||||
\fB-timeprec \fIn\fR
|
||||
Number of significant digits in timestamps (0:S, [3:ms], 6:us).
|
||||
|
||||
.SH COMMANDS
|
||||
.TP
|
||||
\fB-ftrace \fIfile\fR
|
||||
Create HTML output from an existing ftrace file.
|
||||
.TP
|
||||
\fB-dmesg \fIfile\fR
|
||||
Create HTML output from an existing dmesg file.
|
||||
.TP
|
||||
\fB-summary \fIindir\fR
|
||||
Create a summary page of all tests in \fIindir\fR. Creates summary.html
|
||||
in the current folder. The output page is a table of tests with
|
||||
suspend and resume values sorted by suspend mode, host, and kernel.
|
||||
Includes test averages by mode and links to the test html files.
|
||||
.TP
|
||||
\fB-modes\fR
|
||||
List available suspend modes.
|
||||
.TP
|
||||
\fB-status\fR
|
||||
Test to see if the system is able to run this tool. Use this along
|
||||
with any options you intend to use to see if they will work.
|
||||
.TP
|
||||
\fB-fpdt\fR
|
||||
Print out the contents of the ACPI Firmware Performance Data Table.
|
||||
.TP
|
||||
\fB-usbtopo\fR
|
||||
Print out the current USB topology with power info.
|
||||
.TP
|
||||
\fB-usbauto\fR
|
||||
Enable autosuspend for all connected USB devices.
|
||||
.TP
|
||||
\fB-flist\fR
|
||||
Print the list of ftrace functions currently being captured. Functions
|
||||
that are not available as symbols in the current kernel are shown in red.
|
||||
By default, the tool traces a list of important suspend/resume functions
|
||||
in order to better fill out the timeline. If the user has added their own
|
||||
with -fadd they will also be checked.
|
||||
.TP
|
||||
\fB-flistall\fR
|
||||
Print all ftrace functions capable of being captured. These are all the
|
||||
possible values you can add to trace via the -fadd argument.
|
||||
|
||||
.SH EXAMPLES
|
||||
.SS "Simple Commands"
|
||||
Check which suspend modes are currently supported.
|
||||
.IP
|
||||
\f(CW$ sleepgraph -modes\fR
|
||||
.PP
|
||||
Read the Firmware Performance Data Table (FPDT)
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -fpdt\fR
|
||||
.PP
|
||||
Print out the current USB power topology
|
||||
.IP
|
||||
\f(CW$ sleepgraph -usbtopo
|
||||
.PP
|
||||
Verify that you can run a command with a set of arguments
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -f -rtcwake 30 -status
|
||||
.PP
|
||||
Generate a summary of all timelines in a particular folder.
|
||||
.IP
|
||||
\f(CW$ sleepgraph -summary ~/workspace/myresults/\fR
|
||||
.PP
|
||||
Re-generate the html output from a previous run's dmesg and ftrace log.
|
||||
.IP
|
||||
\f(CW$ sleepgraph -dmesg myhost_mem_dmesg.txt -ftrace myhost_mem_ftrace.txt\fR
|
||||
.PP
|
||||
|
||||
.SS "Capturing Simple Timelines"
|
||||
Execute a mem suspend with a 15 second wakeup. Include the logs in the html.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -rtcwake 15 -addlogs\fR
|
||||
.PP
|
||||
Execute a standby with a 15 second wakeup. Change the output folder name.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m standby -rtcwake 15 -o "standby-{hostname}-{date}-{time}"\fR
|
||||
.PP
|
||||
Execute a freeze with no wakeup (require keypress). Change output folder name.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m freeze -rtcwake off -o "freeze-{hostname}-{date}-{time}"\fR
|
||||
.PP
|
||||
|
||||
.SS "Capturing Advanced Timelines"
|
||||
Execute a suspend & include dev mode source calls, limit callbacks to 5ms or larger.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -dev -mindev 5\fR
|
||||
.PP
|
||||
Run two suspends back to back, include a 500ms delay before, after, and in between runs.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -x2 -predelay 500 -x2delay 500 -postdelay 500\fR
|
||||
.PP
|
||||
Do a batch run of 10 freezes with 30 seconds delay between runs.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m freeze -rtcwake 15 -multi 10 30\fR
|
||||
.PP
|
||||
Execute a suspend using a custom command.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -cmd "echo mem > /sys/power/state" -rtcwake 15\fR
|
||||
.PP
|
||||
|
||||
|
||||
.SS "Capturing Timelines with Callgraph Data"
|
||||
Add device callgraphs. Limit the trace depth and only show callgraphs 10ms or larger.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -f -maxdepth 5 -mincg 10\fR
|
||||
.PP
|
||||
Capture a full callgraph across all suspend, then filter the html by a single phase.
|
||||
.IP
|
||||
\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -f\fR
|
||||
.IP
|
||||
\f(CW$ sleepgraph -dmesg host_mem_dmesg.txt -ftrace host_mem_ftrace.txt -f -cgphase resume
|
||||
.PP
|
||||
|
||||
.SH "SEE ALSO"
|
||||
dmesg(1)
|
||||
.PP
|
||||
.SH AUTHOR
|
||||
.nf
|
||||
Written by Todd Brandt <todd.e.brandt@linux.intel.com>
|
||||
|
|
@ -353,6 +353,14 @@ def split_csv():
|
|||
os.system('grep -m 1 common_cpu cpu.csv > cpu{:0>3}.csv'.format(index))
|
||||
os.system('grep CPU_{:0>3} cpu.csv >> cpu{:0>3}.csv'.format(index, index))
|
||||
|
||||
def fix_ownership(path):
|
||||
"""Change the owner of the file to SUDO_UID, if required"""
|
||||
|
||||
uid = os.environ.get('SUDO_UID')
|
||||
gid = os.environ.get('SUDO_GID')
|
||||
if uid is not None:
|
||||
os.chown(path, int(uid), int(gid))
|
||||
|
||||
def cleanup_data_files():
|
||||
""" clean up existing data files """
|
||||
|
||||
|
|
@ -518,12 +526,16 @@ else:
|
|||
|
||||
if not os.path.exists('results'):
|
||||
os.mkdir('results')
|
||||
# The regular user needs to own the directory, not root.
|
||||
fix_ownership('results')
|
||||
|
||||
os.chdir('results')
|
||||
if os.path.exists(testname):
|
||||
print('The test name directory already exists. Please provide a unique test name. Test re-run not supported, yet.')
|
||||
sys.exit()
|
||||
os.mkdir(testname)
|
||||
# The regular user needs to own the directory, not root.
|
||||
fix_ownership(testname)
|
||||
os.chdir(testname)
|
||||
|
||||
# Temporary (or perhaps not)
|
||||
|
|
@ -566,4 +578,9 @@ plot_scaled_cpu()
|
|||
plot_boost_cpu()
|
||||
plot_ghz_cpu()
|
||||
|
||||
# It is preferrable, but not necessary, that the regular user owns the files, not root.
|
||||
for root, dirs, files in os.walk('.'):
|
||||
for f in files:
|
||||
fix_ownership(f)
|
||||
|
||||
os.chdir('../../')
|
||||
|
|
|
|||
Loading…
Reference in a new issue