mercurial-scm/hg: comparison mercurial/statprof.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 }
 ###########################################################################
 ## Utils
 def clock():
 times = os.times()
 return (times[0] + times[1], times[4])
 ###########################################################################
 ## Collection data structures
 class ProfileState(object):
 def __init__(self, frequency=None):
 self.reset(frequency)
 self.track = 'cpu'
 def timeidx(self):
 if self.track == 'real':
 return 1
 return 0
 state = ProfileState()
 class CodeSite(object):
 cache = {}
 self.function = function
 self.source = None
 def __eq__(self, other):
 try:
-return (self.lineno == other.lineno and
+return self.lineno == other.lineno and self.path == other.path
-self.path == other.path)
 except:
 return False
 def __hash__(self):
 return hash((self.lineno, self.path))
 if self.source is None:
 self.source = ''
 source = self.source
 if len(source) > length:
-source = source[:(length - 3)] + "..."
+source = source[: (length - 3)] + "..."
 return source
 def filename(self):
 return os.path.basename(self.path)
 def skipname(self):
 return r'%s:%s' % (self.filename(), self.function)
 class Sample(object):
 __slots__ = (r'stack', r'time')
 def __init__(self, stack, time):
 @classmethod
 def from_frame(cls, frame, time):
 stack = []
 while frame:
-stack.append(CodeSite.get(
+stack.append(
-pycompat.sysbytes(frame.f_code.co_filename),
+CodeSite.get(
-frame.f_lineno,
+pycompat.sysbytes(frame.f_code.co_filename),
-pycompat.sysbytes(frame.f_code.co_name)))
+frame.f_lineno,
+pycompat.sysbytes(frame.f_code.co_name),
+)
+)
 frame = frame.f_back
 return Sample(stack, time)
 ###########################################################################
 ## SIGPROF handler
 def profile_signal_handler(signum, frame):
 if state.profile_level > 0:
 now = clock()
 state.accumulate_time(now)
 timestamp = state.accumulated_time[state.timeidx]
 state.samples.append(Sample.from_frame(frame, timestamp))
-signal.setitimer(signal.ITIMER_PROF,
+signal.setitimer(signal.ITIMER_PROF, state.sample_interval, 0.0)
-state.sample_interval, 0.0)
 state.last_start_time = now
 stopthread = threading.Event()
 def samplerthread(tid):
 while not stopthread.is_set():
 now = clock()
 state.accumulate_time(now)
 state.last_start_time = now
 time.sleep(state.sample_interval)
 stopthread.clear()
 ###########################################################################
 ## Profiling API
 def is_active():
 return state.profile_level > 0
 lastmechanism = None
 def start(mechanism='thread', track='cpu'):
 '''Install the profiling signal handler, and start profiling.'''
-state.track = track # note: nesting different mode won't work
+state.track = track  # note: nesting different mode won't work
 state.profile_level += 1
 if state.profile_level == 1:
 state.last_start_time = clock()
 rpt = state.remaining_prof_time
 state.remaining_prof_time = None
 global lastmechanism
 lastmechanism = mechanism
 if mechanism == 'signal':
 signal.signal(signal.SIGPROF, profile_signal_handler)
-signal.setitimer(signal.ITIMER_PROF,
+signal.setitimer(
-rpt or state.sample_interval, 0.0)
+signal.ITIMER_PROF, rpt or state.sample_interval, 0.0
+)
 elif mechanism == 'thread':
 frame = inspect.currentframe()
 tid = [k for k, f in sys._current_frames().items() if f == frame][0]
-state.thread = threading.Thread(target=samplerthread,
+state.thread = threading.Thread(
-args=(tid,), name="samplerthread")
+target=samplerthread, args=(tid,), name="samplerthread"
+)
 state.thread.start()
 def stop():
 '''Stop profiling, and uninstall the profiling signal handler.'''
 state.profile_level -= 1
 if state.profile_level == 0:
 if statprofpath:
 save_data(statprofpath)
 return state
 def save_data(path):
 with open(path, 'w+') as file:
 file.write("%f %f\n" % state.accumulated_time)
 for sample in state.samples:
 time = sample.time
 stack = sample.stack
-sites = ['\1'.join([s.path, b'%d' % s.lineno, s.function])
+sites = [
-for s in stack]
+'\1'.join([s.path, b'%d' % s.lineno, s.function]) for s in stack
+]
 file.write("%d\0%s\n" % (time, '\0'.join(sites)))
 def load_data(path):
 lines = open(path, 'rb').read().splitlines()
 state.accumulated_time = [float(value) for value in lines[0].split()]
 time = float(parts[0])
 rawsites = parts[1:]
 sites = []
 for rawsite in rawsites:
 siteparts = rawsite.split('\1')
-sites.append(CodeSite.get(siteparts[0], int(siteparts[1]),
+sites.append(
-siteparts[2]))
+CodeSite.get(siteparts[0], int(siteparts[1]), siteparts[2])
+)
 state.samples.append(Sample(sites, time))
 def reset(frequency=None):
 '''Clear out the state of the profiler.  Do not call while the
 profiler is running.
 ###########################################################################
 ## Reporting API
 class SiteStats(object):
 def __init__(self, site):
 self.site = site
 self.selfcount = 0
 self.totalcount = 0
 if i == 0:
 sitestat.addself()
 return [s for s in stats.itervalues()]
 class DisplayFormats:
 ByLine = 0
 ByMethod = 1
 AboutMethod = 2
 Hotpath = 3
 FlameGraph = 4
 Json = 5
 Chrome = 6
 def display(fp=None, format=3, data=None, **kwargs):
 '''Print statistics, either to stdout or the given file object.'''
 if data is None:
 data = state
 if fp is None:
 import sys
 fp = sys.stdout
 if len(data.samples) == 0:
 fp.write(b'No samples recorded.\n')
 return
 if format not in (DisplayFormats.Json, DisplayFormats.Chrome):
 fp.write(b'---\n')
 fp.write(b'Sample count: %d\n' % len(data.samples))
 fp.write(b'Total time: %f seconds (%f wall)\n' % data.accumulated_time)
 def display_by_line(data, fp):
 '''Print the profiler data with each sample line represented
 as one row in a table.  Sorted by self-time per line.'''
 stats = SiteStats.buildstats(data.samples)
 stats.sort(reverse=True, key=lambda x: x.selfseconds())
-fp.write(b'%5.5s %10.10s   %7.7s  %-8.8s\n' % (
+fp.write(
-b'%  ', b'cumulative', b'self', b''))
+b'%5.5s %10.10s   %7.7s  %-8.8s\n'
-fp.write(b'%5.5s  %9.9s  %8.8s  %-8.8s\n' % (
+% (b'%  ', b'cumulative', b'self', b'')
-b"time", b"seconds", b"seconds", b"name"))
+)
+fp.write(
+b'%5.5s  %9.9s  %8.8s  %-8.8s\n'
+% (b"time", b"seconds", b"seconds", b"name")
+)
 for stat in stats:
 site = stat.site
-sitelabel = '%s:%d:%s' % (site.filename(),
+sitelabel = '%s:%d:%s' % (site.filename(), site.lineno, site.function)
-site.lineno,
+fp.write(
-site.function)
+b'%6.2f %9.2f %9.2f  %s\n'
-fp.write(b'%6.2f %9.2f %9.2f  %s\n' % (
+% (
-stat.selfpercent(), stat.totalseconds(),
+stat.selfpercent(),
-stat.selfseconds(), sitelabel))
+stat.totalseconds(),
+stat.selfseconds(),
+sitelabel,
+)
+)
 def display_by_method(data, fp):
 '''Print the profiler data with each sample function represented
 as one row in a table.  Important lines within that function are
 output as nested rows.  Sorted by self-time per line.'''
-fp.write(b'%5.5s %10.10s   %7.7s  %-8.8s\n' %
+fp.write(
-('%  ', 'cumulative', 'self', ''))
+b'%5.5s %10.10s   %7.7s  %-8.8s\n' % ('%  ', 'cumulative', 'self', '')
-fp.write(b'%5.5s  %9.9s  %8.8s  %-8.8s\n' %
+)
-("time", "seconds", "seconds", "name"))
+fp.write(
+b'%5.5s  %9.9s  %8.8s  %-8.8s\n'
+% ("time", "seconds", "seconds", "name")
+)
 stats = SiteStats.buildstats(data.samples)
 grouped = defaultdict(list)
 for stat in stats:
 for stat in sitestats:
 total_cum_sec += stat.totalseconds()
 total_self_sec += stat.selfseconds()
 total_percent += stat.selfpercent()
-functiondata.append((fname,
+functiondata.append(
-total_cum_sec,
+(fname, total_cum_sec, total_self_sec, total_percent, sitestats)
-total_self_sec,
+)
-total_percent,
-sitestats))
 # sort by total self sec
 functiondata.sort(reverse=True, key=lambda x: x[2])
 for function in functiondata:
 if function[3] < 0.05:
 continue
-fp.write(b'%6.2f %9.2f %9.2f  %s\n' % (
+fp.write(
-function[3], # total percent
+b'%6.2f %9.2f %9.2f  %s\n'
-function[1], # total cum sec
+% (
-function[2], # total self sec
+function[3],  # total percent
-function[0])) # file:function
+function[1],  # total cum sec
+function[2],  # total self sec
+function[0],
+)
+)  # file:function
 function[4].sort(reverse=True, key=lambda i: i.selfseconds())
 for stat in function[4]:
 # only show line numbers for significant locations (>1% time spent)
 if stat.selfpercent() > 1:
 source = stat.site.getsource(25)
-if sys.version_info.major >= 3 and not isinstance(source, bytes):
+if sys.version_info.major >= 3 and not isinstance(
+source, bytes
+):
 source = pycompat.bytestr(source)
-stattuple = (stat.selfpercent(), stat.selfseconds(),
+stattuple = (
-stat.site.lineno, source)
+stat.selfpercent(),
+stat.selfseconds(),
+stat.site.lineno,
+source,
+)
 fp.write(b'%33.0f%% %6.2f   line %d: %s\n' % stattuple)
 def display_about_method(data, fp, function=None, **kwargs):
 if function is None:
 raise Exception("Invalid function")
 parents = {}
 children = {}
 for sample in data.samples:
 for i, site in enumerate(sample.stack):
-if site.function == function and (not filename
+if site.function == function and (
-or site.filename() == filename):
+not filename or site.filename() == filename
+):
 relevant_samples += 1
 if i != len(sample.stack) - 1:
 parent = sample.stack[i + 1]
 if parent in parents:
 parents[parent] = parents[parent] + 1
 children[site] = 1
 parents = [(parent, count) for parent, count in parents.iteritems()]
 parents.sort(reverse=True, key=lambda x: x[1])
 for parent, count in parents:
-fp.write(b'%6.2f%%   %s:%s   line %s: %s\n' %
+fp.write(
-(count / relevant_samples * 100,
+b'%6.2f%%   %s:%s   line %s: %s\n'
-pycompat.fsencode(parent.filename()),
+% (
-pycompat.sysbytes(parent.function),
+count / relevant_samples * 100,
-parent.lineno,
+pycompat.fsencode(parent.filename()),
-pycompat.sysbytes(parent.getsource(50))))
+pycompat.sysbytes(parent.function),
+parent.lineno,
+pycompat.sysbytes(parent.getsource(50)),
+)
+)
 stats = SiteStats.buildstats(data.samples)
-stats = [s for s in stats
+stats = [
-if s.site.function == function and
+s
-(not filename or s.site.filename() == filename)]
+for s in stats
+if s.site.function == function
+and (not filename or s.site.filename() == filename)
+]
 total_cum_sec = 0
 total_self_sec = 0
 total_self_percent = 0
 total_cum_percent = 0
 total_cum_percent += stat.totalpercent()
 fp.write(
 b'\n    %s:%s    Total: %0.2fs (%0.2f%%)    Self: %0.2fs (%0.2f%%)\n\n'
 % (
 pycompat.sysbytes(filename or '___'),
 pycompat.sysbytes(function),
 total_cum_sec,
 total_cum_percent,
 total_self_sec,
-total_self_percent
+total_self_percent,
-))
+)
+)
 children = [(child, count) for child, count in children.iteritems()]
 children.sort(reverse=True, key=lambda x: x[1])
 for child, count in children:
-fp.write(b'        %6.2f%%   line %s: %s\n' %
+fp.write(
-(count / relevant_samples * 100, child.lineno,
+b'        %6.2f%%   line %s: %s\n'
-pycompat.sysbytes(child.getsource(50))))
+% (
+count / relevant_samples * 100,
+child.lineno,
+pycompat.sysbytes(child.getsource(50)),
+)
+)
 def display_hotpath(data, fp, limit=0.05, **kwargs):
 class HotNode(object):
 def __init__(self, site):
 self.site = site
 lasttime = sample.time
 showtime = kwargs.get(r'showtime', True)
 def _write(node, depth, multiple_siblings):
 site = node.site
-visiblechildren = [c for c in node.children.itervalues()
+visiblechildren = [
-if c.count >= (limit * root.count)]
+c
+for c in node.children.itervalues()
+if c.count >= (limit * root.count)
+]
 if site:
 indent = depth * 2 - 1
 filename = ''
 function = ''
 if len(node.children) > 0:
 childsite = list(node.children.itervalues())[0].site
 filename = (childsite.filename() + ':').ljust(15)
 function = childsite.function
 # lots of string formatting
-listpattern = ''.ljust(indent) +\
+listpattern = (
-('\\' if multiple_siblings else '|') +\
+''.ljust(indent)
-' %4.1f%%' +\
++ ('\\' if multiple_siblings else '|')
-(' %5.2fs' % node.count if showtime else '') +\
++ ' %4.1f%%'
-'  %s %s'
++ (' %5.2fs' % node.count if showtime else '')
-liststring = listpattern % (node.count / root.count * 100,
++ '  %s %s'
-filename, function)
+)
+liststring = listpattern % (
+node.count / root.count * 100,
+filename,
+function,
+)
 codepattern = '%' + ('%d' % (55 - len(liststring))) + 's %d:  %s'
 codestring = codepattern % ('line', site.lineno, site.getsource(30))
 finalstring = liststring + codestring
 childrensamples = sum([c.count for c in node.children.itervalues()])
 _write(child, newdepth, len(visiblechildren) > 1)
 if root.count > 0:
 _write(root, 0, False)
 def write_to_flame(data, fp, scriptpath=None, outputfile=None, **kwargs):
 if scriptpath is None:
 scriptpath = encoding.environ['HOME'] + '/flamegraph.pl'
 if not os.path.exists(scriptpath):
 fp.write(b'error: missing %s\n' % scriptpath)
 outputfile = '~/flamegraph.svg'
 os.system("perl ~/flamegraph.pl %s > %s" % (path, outputfile))
 fp.write(b'Written to %s\n' % outputfile)
 _pathcache = {}
 def simplifypath(path):
 '''Attempt to make the path to a Python module easier to read by
 removing whatever part of the Python search path it was found
 on.'''
 return _pathcache[path]
 hgpath = encoding.__file__.rsplit(os.sep, 2)[0]
 for p in [hgpath] + sys.path:
 prefix = p + os.sep
 if path.startswith(prefix):
-path = path[len(prefix):]
+path = path[len(prefix) :]
 break
 _pathcache[path] = path
 return path
 def write_to_json(data, fp):
 samples = []
 for sample in data.samples:
 stack = []
 for frame in sample.stack:
 stack.append(
-(pycompat.sysstr(frame.path),
+(
-frame.lineno,
+pycompat.sysstr(frame.path),
-pycompat.sysstr(frame.function)))
+frame.lineno,
+pycompat.sysstr(frame.function),
+)
+)
 samples.append((sample.time, stack))
 data = json.dumps(samples)
 if not isinstance(data, bytes):
 data = data.encode('utf-8')
 fp.write(data)
 def write_to_chrome(data, fp, minthreshold=0.005, maxthreshold=0.999):
 samples = []
 laststack = collections.deque()
 lastseen = collections.deque()
 # The Chrome tracing format allows us to use a compact stack
 # representation to save space. It's fiddly but worth it.
 # We maintain a bijection between stack and ID.
 stack2id = {}
-id2stack = [] # will eventually be rendered
+id2stack = []  # will eventually be rendered
 def stackid(stack):
 if not stack:
 return
 if stack in stack2id:
 oldtime, oldidx = lastseen.popleft()
 duration = sample.time - oldtime
 if minthreshold <= duration <= maxthreshold:
 # ensure no zero-duration events
 sampletime = max(oldtime + clamp, sample.time)
-samples.append(dict(ph=r'E', name=oldfunc, cat=oldcat, sf=oldsid,
+samples.append(
-ts=sampletime*1e6, pid=0))
+dict(
+ph=r'E',
+name=oldfunc,
+cat=oldcat,
+sf=oldsid,
+ts=sampletime * 1e6,
+pid=0,
+)
+)
 else:
 blacklist.add(oldidx)
 # Much fiddling to synthesize correctly(ish) nested begin/end
 # events given only stack snapshots.
 for sample in data.samples:
-stack = tuple(((r'%s:%d' % (simplifypath(pycompat.sysstr(frame.path)),
+stack = tuple(
-frame.lineno),
+(
-pycompat.sysstr(frame.function))
+(
-for frame in sample.stack))
+r'%s:%d'
+% (simplifypath(pycompat.sysstr(frame.path)), frame.lineno),
+pycompat.sysstr(frame.function),
+)
+for frame in sample.stack
+)
+)
 qstack = collections.deque(stack)
 if laststack == qstack:
 continue
 while laststack and qstack and laststack[-1] == qstack[-1]:
 laststack.pop()
 for f in reversed(qstack):
 lastseen.appendleft((sample.time, len(samples)))
 laststack.appendleft(f)
 path, name = f
 sid = stackid(tuple(laststack))
-samples.append(dict(ph=r'B', name=name, cat=path,
+samples.append(
-ts=sample.time*1e6, sf=sid, pid=0))
+dict(
+ph=r'B',
+name=name,
+cat=path,
+ts=sample.time * 1e6,
+sf=sid,
+pid=0,
+)
+)
 laststack = collections.deque(stack)
 while laststack:
 poplast()
-events = [sample for idx, sample in enumerate(samples)
+events = [
-if idx not in blacklist]
+sample for idx, sample in enumerate(samples) if idx not in blacklist
-frames = collections.OrderedDict((str(k), v)
+]
-for (k,v) in enumerate(id2stack))
+frames = collections.OrderedDict(
+(str(k), v) for (k, v) in enumerate(id2stack)
+)
 data = json.dumps(dict(traceEvents=events, stackFrames=frames), indent=1)
 if not isinstance(data, bytes):
 data = data.encode('utf-8')
 fp.write(data)
 fp.write('\n')
 def printusage():
-print(r"""
+print(
+r"""
 The statprof command line allows you to inspect the last profile's results in
 the following forms:
 usage:
 hotpath [-l --limit percent]
 function [filename:]functionname
 Shows the callers and callees of a particular function.
 flame [-s --script-path] [-o --output-file path]
 Writes out a flamegraph to output-file (defaults to ~/flamegraph.svg)
 Requires that ~/flamegraph.pl exist.
-(Specify alternate script path with --script-path.)""")
+(Specify alternate script path with --script-path.)"""
+)
 def main(argv=None):
 if argv is None:
 argv = sys.argv
 printusage()
 return 0
 # process options
 try:
-opts, args = pycompat.getoptb(sys.argv[optstart:], "hl:f:o:p:",
+opts, args = pycompat.getoptb(
-["help", "limit=", "file=", "output-file=", "script-path="])
+sys.argv[optstart:],
+"hl:f:o:p:",
+["help", "limit=", "file=", "output-file=", "script-path="],
+)
 except getopt.error as msg:
 print(msg)
 printusage()
 return 2
 display(**pycompat.strkwargs(displayargs))
 return 0
 if __name__ == r"__main__":
 sys.exit(main())

changeset 43076	2372284d9457
parent 43053	9a3be115fb78
child 43077	687b865b95ad