cProfile.py

#! /usr/bin/env python3

"""Python interface for the 'lsprof' profiler.
 Compatible with the 'profile' module.
"""

__all__= ["run", "runctx", "Profile"]

import_lsprof
importprofileas_pyprofile

# ____________________________________________________________
# Simple interface

defrun(statement, filename=None, sort=-1):
return_pyprofile._Utils(Profile).run(statement, filename, sort)

defrunctx(statement, globals, locals, filename=None, sort=-1):
return_pyprofile._Utils(Profile).runctx(statement, globals, locals,
filename, sort)

run.__doc__=_pyprofile.run.__doc__
runctx.__doc__=_pyprofile.runctx.__doc__

# ____________________________________________________________

classProfile(_lsprof.Profiler):
"""Profile(timer=None, timeunit=None, subcalls=True, builtins=True)

 Builds a profiler object using the specified timer function.
 The default timer is a fast built-in one based on real time.
 For custom timer functions returning integers, timeunit can
 be a float specifying a scale (i.e. how long each integer unit
 is, in seconds).
 """

# Most of the functionality is in the base class.
# This subclass only adds convenient and backward-compatible methods.

defprint_stats(self, sort=-1):
importpstats
pstats.Stats(self).strip_dirs().sort_stats(sort).print_stats()

defdump_stats(self, file):
importmarshal
withopen(file, 'wb') asf:
self.create_stats()
marshal.dump(self.stats, f)

defcreate_stats(self):
self.disable()
self.snapshot_stats()

defsnapshot_stats(self):
entries=self.getstats()
self.stats= {}
callersdicts= {}
# call information
forentryinentries:
func=label(entry.code)
nc=entry.callcount# ncalls column of pstats (before '/')
cc=nc-entry.reccallcount# ncalls column of pstats (after '/')
tt=entry.inlinetime# tottime column of pstats
ct=entry.totaltime# cumtime column of pstats
callers= {}
callersdicts[id(entry.code)] =callers
self.stats[func] =cc, nc, tt, ct, callers
# subcall information
forentryinentries:
ifentry.calls:
func=label(entry.code)
forsubentryinentry.calls:
try:
callers=callersdicts[id(subentry.code)]
exceptKeyError:
continue
nc=subentry.callcount
cc=nc-subentry.reccallcount
tt=subentry.inlinetime
ct=subentry.totaltime
iffuncincallers:
prev=callers[func]
nc+=prev[0]
cc+=prev[1]
tt+=prev[2]
ct+=prev[3]
callers[func] =nc, cc, tt, ct

# The following two methods can be called by clients to use
# a profiler to profile a statement, given as a string.

defrun(self, cmd):
import__main__
dict=__main__.__dict__
returnself.runctx(cmd, dict, dict)

defrunctx(self, cmd, globals, locals):
self.enable()
try:
exec(cmd, globals, locals)
finally:
self.disable()
returnself

# This method is more useful to profile a single function call.
defruncall(*args, **kw):
iflen(args) >=2:
self, func, *args=args
elifnotargs:
raiseTypeError("descriptor 'runcall' of 'Profile' object "
"needs an argument")
elif'func'inkw:
func=kw.pop('func')
self, *args=args
else:
raiseTypeError('runcall expected at least 1 positional argument, '
'got %d'% (len(args)-1))

self.enable()
try:
returnfunc(*args, **kw)
finally:
self.disable()

# ____________________________________________________________

deflabel(code):
ifisinstance(code, str):
return ('~', 0, code) # built-in functions ('~' sorts at the end)
else:
return (code.co_filename, code.co_firstlineno, code.co_name)

# ____________________________________________________________

defmain():
importos
importsys
importrunpy
importpstats
fromoptparseimportOptionParser
usage="cProfile.py [-o output_file_path] [-s sort] [-m module | scriptfile] [arg] ..."
parser=OptionParser(usage=usage)
parser.allow_interspersed_args=False
parser.add_option('-o', '--outfile', dest="outfile",
help="Save stats to <outfile>", default=None)
parser.add_option('-s', '--sort', dest="sort",
help="Sort order when printing to stdout, based on pstats.Stats class",
default=-1,
choices=sorted(pstats.Stats.sort_arg_dict_default))
parser.add_option('-m', dest="module", action="store_true",
help="Profile a library module", default=False)

ifnotsys.argv[1:]:
parser.print_usage()
sys.exit(2)

 (options, args) =parser.parse_args()
sys.argv[:] =args

iflen(args) >0:
ifoptions.module:
code="run_module(modname, run_name='__main__')"
globs= {
'run_module': runpy.run_module,
'modname': args[0]
 }
else:
progname=args[0]
sys.path.insert(0, os.path.dirname(progname))
withopen(progname, 'rb') asfp:
code=compile(fp.read(), progname, 'exec')
globs= {
'__file__': progname,
'__name__': '__main__',
'__package__': None,
'__cached__': None,
 }
runctx(code, globs, None, options.outfile, options.sort)
else:
parser.print_usage()
returnparser

# When invoked as main program, invoke the profiler on a script
if__name__=='__main__':
main()