1
# this is copied from the lsprof distro because somehow
2
# it is not installed by distutils
3
# I made one modification to profile so that it returns a pair
4
# instead of just the Stats object
6
from __future__ import absolute_import
10
import cPickle as pickle
19
import thread as _thread
21
from _lsprof import Profiler, profiler_entry
25
__all__ = ['profile', 'Stats']
27
def profile(f, *args, **kwds):
28
"""Run a function profile.
30
Exceptions are not caught: If you need stats even when exceptions are to be
31
raised, pass in a closure that will catch the exceptions and transform them
32
appropriately for your driver function.
34
Important caveat: only one profile can execute at a time. See BzrProfiler
37
:return: The functions return value and a stats object.
39
profiler = BzrProfiler()
42
ret = f(*args, **kwds)
44
stats = profiler.stop()
48
class BzrProfiler(object):
49
"""Bzr utility wrapper around Profiler.
51
For most uses the module level 'profile()' function will be suitable.
52
However profiling when a simple wrapped function isn't available may
53
be easier to accomplish using this class.
55
To use it, create a BzrProfiler and call start() on it. Some arbitrary
56
time later call stop() to stop profiling and retrieve the statistics
57
from the code executed in the interim.
59
Note that profiling involves a threading.Lock around the actual profiling.
60
This is needed because profiling involves global manipulation of the python
61
interpreter state. As such you cannot perform multiple profiles at once.
62
Trying to do so will lock out the second profiler unless the global
63
breezy.lsprof.BzrProfiler.profiler_block is set to 0. Setting it to 0 will
64
cause profiling to fail rather than blocking.
68
"""Serialise rather than failing to profile concurrent profile requests."""
70
profiler_lock = threading.Lock()
71
"""Global lock used to serialise profiles."""
76
This hooks into threading and will record all calls made until
79
self._g_threadmap = {}
81
permitted = self.__class__.profiler_lock.acquire(
82
self.__class__.profiler_block)
84
raise errors.InternalBzrError(msg="Already profiling something")
86
self.p.enable(subcalls=True)
87
threading.setprofile(self._thread_profile)
89
self.__class__.profiler_lock.release()
95
This unhooks from threading and cleans up the profiler, returning
96
the gathered Stats object.
98
:return: A breezy.lsprof.Stats object.
102
for pp in self._g_threadmap.values():
104
threading.setprofile(None)
108
for tid, pp in self._g_threadmap.items():
109
threads[tid] = Stats(pp.getstats(), {})
110
self._g_threadmap = None
111
return Stats(p.getstats(), threads)
113
self.__class__.profiler_lock.release()
115
def _thread_profile(self, f, *args, **kwds):
116
# we lose the first profile point for a new thread in order to
117
# trampoline a new Profile object into place
118
thr = _thread.get_ident()
119
self._g_threadmap[thr] = p = Profiler()
120
# this overrides our sys.setprofile hook:
121
p.enable(subcalls=True, builtins=True)
125
"""Wrapper around the collected data.
127
A Stats instance is created when the profiler finishes. Normal
128
usage is to use save() to write out the data to a file, or pprint()
129
to write human-readable information to the command line.
132
def __init__(self, data, threads):
134
self.threads = threads
136
def sort(self, crit="inlinetime", reverse=True):
137
"""Sort the data by the supplied critera.
139
:param crit: the data attribute used as the sort key."""
140
if crit not in profiler_entry.__dict__ or crit == 'code':
141
raise ValueError("Can't sort by %s" % crit)
143
key_func = operator.attrgetter(crit)
144
self.data.sort(key=key_func, reverse=reverse)
148
e.calls.sort(key=key_func, reverse=reverse)
150
def pprint(self, top=None, file=None):
151
"""Pretty-print the data as plain text for human consumption.
153
:param top: only output the top n entries.
154
The default value of None means output all data.
155
:param file: the output file; if None, output will
156
default to stdout."""
162
cols = "% 12s %12s %11.4f %11.4f %s\n"
163
hcols = "% 12s %12s %12s %12s %s\n"
164
cols2 = "+%12s %12s %11.4f %11.4f + %s\n"
165
file.write(hcols % ("CallCount", "Recursive", "Total(ms)",
166
"Inline(ms)", "module:lineno(function)"))
168
file.write(cols % (e.callcount, e.reccallcount, e.totaltime,
169
e.inlinetime, label(e.code)))
172
file.write(cols % ("+%s" % se.callcount, se.reccallcount,
173
se.totaltime, se.inlinetime,
174
"+%s" % label(se.code)))
177
"""Replace all references to code objects with string
178
descriptions; this makes it possible to pickle the instance."""
180
# this code is probably rather ickier than it needs to be!
181
for i in range(len(self.data)):
183
if not isinstance(e.code, str):
184
self.data[i] = type(e)((label(e.code),) + e[1:])
186
for j in range(len(e.calls)):
188
if not isinstance(se.code, str):
189
e.calls[j] = type(se)((label(se.code),) + se[1:])
190
for s in self.threads.values():
193
def calltree(self, file):
194
"""Output profiling data in calltree format (for KCacheGrind)."""
195
_CallTreeFilter(self.data).output(file)
197
def save(self, filename, format=None):
198
"""Save profiling data to a file.
200
:param filename: the name of the output file
201
:param format: 'txt' for a text representation;
202
'callgrind' for calltree format;
203
otherwise a pickled Python object. A format of None indicates
204
that the format to use is to be found from the filename. If
205
the name starts with callgrind.out, callgrind format is used
206
otherwise the format is given by the filename extension.
209
basename = os.path.basename(filename)
210
if basename.startswith('callgrind.out'):
213
ext = os.path.splitext(filename)[1]
216
with open(filename, 'wb') as outfile:
217
if format == "callgrind":
218
# The callgrind format states it is 'ASCII based':
219
# <http://valgrind.org/docs/manual/cl-format.html>
220
# But includes filenames so lets ignore and use UTF-8.
221
self.calltree(codecs.getwriter('utf-8')(outfile))
222
elif format == "txt":
223
self.pprint(file=codecs.getwriter('utf-8')(outfile))
226
pickle.dump(self, outfile, 2)
229
class _CallTreeFilter(object):
230
"""Converter of a Stats object to input suitable for KCacheGrind.
232
This code is taken from http://ddaa.net/blog/python/lsprof-calltree
233
with the changes made by J.P. Calderone and Itamar applied. Note that
234
isinstance(code, str) needs to be used at times to determine if the code
235
object is actually an external code object (with a filename, etc.) or
239
def __init__(self, data):
243
def output(self, out_file):
244
self.out_file = out_file
245
out_file.write('events: Ticks\n')
246
self._print_summary()
247
for entry in self.data:
250
def _print_summary(self):
252
for entry in self.data:
253
totaltime = int(entry.totaltime * 1000)
254
max_cost = max(max_cost, totaltime)
255
self.out_file.write('summary: %d\n' % (max_cost,))
257
def _entry(self, entry):
258
out_file = self.out_file
260
inlinetime = int(entry.inlinetime * 1000)
261
#out_file.write('ob=%s\n' % (code.co_filename,))
262
if isinstance(code, str):
263
out_file.write('fi=~\n')
265
out_file.write('fi=%s\n' % (code.co_filename,))
266
out_file.write('fn=%s\n' % (label(code, True),))
267
if isinstance(code, str):
268
out_file.write('0 %s\n' % (inlinetime,))
270
out_file.write('%d %d\n' % (code.co_firstlineno, inlinetime))
271
# recursive calls are counted in entry.calls
276
if isinstance(code, str):
279
lineno = code.co_firstlineno
280
for subentry in calls:
281
self._subentry(lineno, subentry)
284
def _subentry(self, lineno, subentry):
285
out_file = self.out_file
287
totaltime = int(subentry.totaltime * 1000)
288
#out_file.write('cob=%s\n' % (code.co_filename,))
289
if isinstance(code, str):
290
out_file.write('cfi=~\n')
291
out_file.write('cfn=%s\n' % (label(code, True),))
292
out_file.write('calls=%d 0\n' % (subentry.callcount,))
294
out_file.write('cfi=%s\n' % (code.co_filename,))
295
out_file.write('cfn=%s\n' % (label(code, True),))
296
out_file.write('calls=%d %d\n' % (
297
subentry.callcount, code.co_firstlineno))
298
out_file.write('%d %d\n' % (lineno, totaltime))
302
def label(code, calltree=False):
303
if isinstance(code, str):
306
mname = _fn2mod[code.co_filename]
308
for k, v in sys.modules.items():
311
if getattr(v, '__file__', None) is None:
313
if not isinstance(v.__file__, str):
315
if v.__file__.startswith(code.co_filename):
316
mname = _fn2mod[code.co_filename] = k
319
mname = _fn2mod[code.co_filename] = '<%s>'%code.co_filename
321
return '%s %s:%d' % (code.co_name, mname, code.co_firstlineno)
323
return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
327
sys.argv = sys.argv[1:]
329
sys.stderr.write("usage: lsprof.py <script> <arguments...>\n")
332
result, stats = profile(runpy.run_path, sys.argv[0], run_name='__main__')
337
if __name__ == '__main__':
added
removed
breezy/lsprof.py
