"""High-perfomance logging profiler, mostly written in C.""" | |
import _hotshot | |
from _hotshot import ProfilerError | |
from warnings import warnpy3k as _warnpy3k | |
_warnpy3k("The 'hotshot' module is not supported in 3.x, " | |
"use the 'profile' module instead.", stacklevel=2) | |
class Profile: | |
def __init__(self, logfn, lineevents=0, linetimings=1): | |
self.lineevents = lineevents and 1 or 0 | |
self.linetimings = (linetimings and lineevents) and 1 or 0 | |
self._prof = p = _hotshot.profiler( | |
logfn, self.lineevents, self.linetimings) | |
# Attempt to avoid confusing results caused by the presence of | |
# Python wrappers around these functions, but only if we can | |
# be sure the methods have not been overridden or extended. | |
if self.__class__ is Profile: | |
self.close = p.close | |
self.start = p.start | |
self.stop = p.stop | |
self.addinfo = p.addinfo | |
def close(self): | |
"""Close the logfile and terminate the profiler.""" | |
self._prof.close() | |
def fileno(self): | |
"""Return the file descriptor of the profiler's log file.""" | |
return self._prof.fileno() | |
def start(self): | |
"""Start the profiler.""" | |
self._prof.start() | |
def stop(self): | |
"""Stop the profiler.""" | |
self._prof.stop() | |
def addinfo(self, key, value): | |
"""Add an arbitrary labelled value to the profile log.""" | |
self._prof.addinfo(key, value) | |
# These methods offer the same interface as the profile.Profile class, | |
# but delegate most of the work to the C implementation underneath. | |
def run(self, cmd): | |
"""Profile an exec-compatible string in the script | |
environment. | |
The globals from the __main__ module are used as both the | |
globals and locals for the script. | |
""" | |
import __main__ | |
dict = __main__.__dict__ | |
return self.runctx(cmd, dict, dict) | |
def runctx(self, cmd, globals, locals): | |
"""Evaluate an exec-compatible string in a specific | |
environment. | |
The string is compiled before profiling begins. | |
""" | |
code = compile(cmd, "<string>", "exec") | |
self._prof.runcode(code, globals, locals) | |
return self | |
def runcall(self, func, *args, **kw): | |
"""Profile a single call of a callable. | |
Additional positional and keyword arguments may be passed | |
along; the result of the call is returned, and exceptions are | |
allowed to propogate cleanly, while ensuring that profiling is | |
disabled on the way out. | |
""" | |
return self._prof.runcall(func, args, kw) |