This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5210

statprof: clean up unicode/bytes a little
ClosedPublic

Authored by durin42 on Nov 1 2018, 5:17 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG8664fdc1cfb3: statprof: clean up unicode/bytes a little
Summary

I'm not really sure how this worked before, but something perturbed it
and what I've got in this change I believe is a little tidier. This
fixes test-profile.t on Python 3.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Nov 1 2018, 5:17 PM
yuja added a subscriber: yuja.Nov 2 2018, 9:32 PM

Queued, thanks.

  • sitelabel = '%s:%d:%s' % (pycompat.fsencode(site.filename()),

+ sitelabel = '%s:%d:%s' % (site.filename(),

Maybe missing b'' ?

  • pycompat.sysbytes(site.function))

+ site.function)

fp.write(b'%6.2f %9.2f %9.2f  %s\n' % (
    stat.selfpercent(), stat.totalseconds(),
    stat.selfseconds(), sitelabel))
Closed by commit rHG8664fdc1cfb3: statprof: clean up unicode/bytes a little (authored by durin42). · Explain WhyNov 2 2018, 9:44 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/statprof.py (25 lines)

Diff 12365

mercurial/statprof.py

cls.cache[k] = v cls.cache[k] = v
return v return v
def getsource(self, length): def getsource(self, length):
if self.source is None: if self.source is None:
lineno = self.lineno - 1 lineno = self.lineno - 1
fp = None fp = None
try: try:
fp = open(self.path) fp = open(self.path, 'rb')
for i, line in enumerate(fp): for i, line in enumerate(fp):
if i == lineno: if i == lineno:
self.source = line.strip() self.source = line.strip()
break break
except: except:
pass pass
finally: finally:
if fp: if fp:
self.stack = stack self.stack = stack
self.time = time self.time = time
@classmethod @classmethod
def from_frame(cls, frame, time): def from_frame(cls, frame, time):
stack = [] stack = []
while frame: while frame:
stack.append(CodeSite.get(frame.f_code.co_filename, frame.f_lineno, stack.append(CodeSite.get(
frame.f_code.co_name)) pycompat.sysbytes(frame.f_code.co_filename),
frame.f_lineno,
pycompat.sysbytes(frame.f_code.co_name)))
frame = frame.f_back frame = frame.f_back
return Sample(stack, time) return Sample(stack, time)
########################################################################### ###########################################################################
## SIGPROF handler ## SIGPROF handler
def profile_signal_handler(signum, frame): def profile_signal_handler(signum, frame):
for sample in state.samples: for sample in state.samples:
time = sample.time time = sample.time
stack = sample.stack stack = sample.stack
sites = ['\1'.join([s.path, b'%d' % s.lineno, s.function]) sites = ['\1'.join([s.path, b'%d' % s.lineno, s.function])
for s in stack] for s in stack]
file.write("%d\0%s\n" % (time, '\0'.join(sites))) file.write("%d\0%s\n" % (time, '\0'.join(sites)))
def load_data(path): def load_data(path):
lines = open(path, 'r').read().splitlines() lines = open(path, 'rb').read().splitlines()
state.accumulated_time = [float(value) for value in lines[0].split()] state.accumulated_time = [float(value) for value in lines[0].split()]
state.samples = [] state.samples = []
for line in lines[1:]: for line in lines[1:]:
parts = line.split('\0') parts = line.split('\0')
time = float(parts[0]) time = float(parts[0])
rawsites = parts[1:] rawsites = parts[1:]
sites = [] sites = []
fp.write(b'%5.5s %10.10s %7.7s %-8.8s\n' % ( fp.write(b'%5.5s %10.10s %7.7s %-8.8s\n' % (
b'% ', b'cumulative', b'self', b'')) b'% ', b'cumulative', b'self', b''))
fp.write(b'%5.5s %9.9s %8.8s %-8.8s\n' % ( fp.write(b'%5.5s %9.9s %8.8s %-8.8s\n' % (
b"time", b"seconds", b"seconds", b"name")) b"time", b"seconds", b"seconds", b"name"))
for stat in stats: for stat in stats:
site = stat.site site = stat.site
sitelabel = '%s:%d:%s' % (pycompat.fsencode(site.filename()), sitelabel = '%s:%d:%s' % (site.filename(),
site.lineno, site.lineno,
pycompat.sysbytes(site.function)) site.function)
fp.write(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.totalseconds(),
stat.selfseconds(), sitelabel)) stat.selfseconds(), sitelabel))
def display_by_method(data, fp): def display_by_method(data, fp):
'''Print the profiler data with each sample function represented '''Print the profiler data with each sample function represented
as one row in a table. Important lines within that function are as one row in a table. Important lines within that function are
output as nested rows. Sorted by self-time per line.''' output as nested rows. Sorted by self-time per line.'''
fp.write(b'%5.5s %10.10s %7.7s %-8.8s\n' % fp.write(b'%5.5s %10.10s %7.7s %-8.8s\n' %
('% ', 'cumulative', 'self', '')) ('% ', 'cumulative', 'self', ''))
fp.write(b'%5.5s %9.9s %8.8s %-8.8s\n' % fp.write(b'%5.5s %9.9s %8.8s %-8.8s\n' %
("time", "seconds", "seconds", "name")) ("time", "seconds", "seconds", "name"))
stats = SiteStats.buildstats(data.samples) stats = SiteStats.buildstats(data.samples)
grouped = defaultdict(list) grouped = defaultdict(list)
for stat in stats: for stat in stats:
grouped[stat.site.filename() + r":" + stat.site.function].append(stat) grouped[stat.site.filename() + b":" + stat.site.function].append(stat)
# compute sums for each function # compute sums for each function
functiondata = [] functiondata = []
for fname, sitestats in grouped.iteritems(): for fname, sitestats in grouped.iteritems():
total_cum_sec = 0 total_cum_sec = 0
total_self_sec = 0 total_self_sec = 0
total_percent = 0 total_percent = 0
for stat in sitestats: for stat in sitestats:
for function in functiondata: for function in functiondata:
if function[3] < 0.05: if function[3] < 0.05:
continue continue
fp.write(b'%6.2f %9.2f %9.2f %s\n' % ( fp.write(b'%6.2f %9.2f %9.2f %s\n' % (
function[3], # total percent function[3], # total percent
function[1], # total cum sec function[1], # total cum sec
function[2], # total self sec function[2], # total self sec
pycompat.sysbytes(function[0]))) # file:function function[0])) # file:function
function[4].sort(reverse=True, key=lambda i: i.selfseconds()) function[4].sort(reverse=True, key=lambda i: i.selfseconds())
for stat in function[4]: for stat in function[4]:
# only show line numbers for significant locations (>1% time spent) # only show line numbers for significant locations (>1% time spent)
if stat.selfpercent() > 1: if stat.selfpercent() > 1:
source = stat.site.getsource(25) 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) source = pycompat.bytestr(source)
function = childsite.function function = childsite.function
# lots of string formatting # lots of string formatting
listpattern = ''.ljust(indent) +\ listpattern = ''.ljust(indent) +\
('\\' if multiple_siblings else '|') +\ ('\\' if multiple_siblings else '|') +\
' %4.1f%% %s %s' ' %4.1f%% %s %s'
liststring = listpattern % (node.count / root.count * 100, liststring = listpattern % (node.count / root.count * 100,
filename, function) filename, function)
codepattern = '%' + str(55 - len(liststring)) + 's %s: %s' codepattern = '%' + ('%d' % (55 - len(liststring))) + 's %d: %s'
codestring = codepattern % ('line', site.lineno, site.getsource(30)) codestring = codepattern % ('line', site.lineno, site.getsource(30))
finalstring = liststring + codestring finalstring = liststring + codestring
childrensamples = sum([c.count for c in node.children.itervalues()]) childrensamples = sum([c.count for c in node.children.itervalues()])
# Make frames that performed more than 10% of the operation red # Make frames that performed more than 10% of the operation red
if node.count - childrensamples > (0.1 * root.count): if node.count - childrensamples > (0.1 * root.count):
finalstring = '\033[91m' + finalstring + '\033[0m' finalstring = '\033[91m' + finalstring + '\033[0m'
# Make frames that didn't actually perform work dark grey # Make frames that didn't actually perform work dark grey
def write_to_json(data, fp): def write_to_json(data, fp):
samples = [] samples = []
for sample in data.samples: for sample in data.samples:
stack = [] stack = []
for frame in sample.stack: for frame in sample.stack:
stack.append((frame.path, frame.lineno, frame.function)) stack.append(
(pycompat.sysstr(frame.path),
frame.lineno,
pycompat.sysstr(frame.function)))
samples.append((sample.time, stack)) samples.append((sample.time, stack))
data = json.dumps(samples) data = json.dumps(samples)
if not isinstance(data, bytes): if not isinstance(data, bytes):
data = data.encode('utf-8') data = data.encode('utf-8')
fp.write(data) fp.write(data)