3
3
# I made one modification to profile so that it returns a pair
4
4
# instead of just the Stats object
9
11
from _lsprof import Profiler, profiler_entry
11
14
__all__ = ['profile', 'Stats']
16
def _thread_profile(f, *args, **kwds):
17
# we lose the first profile point for a new thread in order to trampoline
18
# a new Profile object into place
20
thr = thread.get_ident()
21
_g_threadmap[thr] = p = Profiler()
22
# this overrides our sys.setprofile hook:
23
p.enable(subcalls=True, builtins=True)
26
16
def profile(f, *args, **kwds):
30
p.enable(subcalls=True)
31
threading.setprofile(_thread_profile)
17
"""Run a function profile.
19
Exceptions are not caught: If you need stats even when exceptions are to be
20
raised, pass in a closure that will catch the exceptions and transform them
21
appropriately for your driver function.
23
:return: The functions return value and a stats object.
25
profiler = BzrProfiler()
33
28
ret = f(*args, **kwds)
36
for pp in _g_threadmap.values():
30
stats = profiler.stop()
34
class BzrProfiler(object):
35
"""Bzr utility wrapper around Profiler.
37
For most uses the module level 'profile()' function will be suitable.
38
However profiling when a simple wrapped function isn't available may
39
be easier to accomplish using this class.
41
To use it, create a BzrProfiler and call start() on it. Some arbitrary
42
time later call stop() to stop profiling and retrieve the statistics
43
from the code executed in the interim.
49
This hooks into threading and will record all calls made until
52
self._g_threadmap = {}
54
self.p.enable(subcalls=True)
55
threading.setprofile(self._thread_profile)
60
This unhooks from threading and cleans up the profiler, returning
61
the gathered Stats object.
63
:return: A bzrlib.lsprof.Stats object.
66
for pp in self._g_threadmap.values():
38
68
threading.setprofile(None)
41
for tid, pp in _g_threadmap.items():
42
threads[tid] = Stats(pp.getstats(), {})
44
return ret, Stats(p.getstats(), threads)
72
for tid, pp in self._g_threadmap.items():
73
threads[tid] = Stats(pp.getstats(), {})
74
self._g_threadmap = None
75
return Stats(p.getstats(), threads)
77
def _thread_profile(self, f, *args, **kwds):
78
# we lose the first profile point for a new thread in order to
79
# trampoline a new Profile object into place
80
thr = thread.get_ident()
81
self._g_threadmap[thr] = p = Profiler()
82
# this overrides our sys.setprofile hook:
83
p.enable(subcalls=True, builtins=True)
47
86
class Stats(object):
104
143
"""Output profiling data in calltree format (for KCacheGrind)."""
105
144
_CallTreeFilter(self.data).output(file)
146
def save(self, filename, format=None):
147
"""Save profiling data to a file.
149
:param filename: the name of the output file
150
:param format: 'txt' for a text representation;
151
'callgrind' for calltree format;
152
otherwise a pickled Python object. A format of None indicates
153
that the format to use is to be found from the filename. If
154
the name starts with callgrind.out, callgrind format is used
155
otherwise the format is given by the filename extension.
158
basename = os.path.basename(filename)
159
if basename.startswith('callgrind.out'):
162
ext = os.path.splitext(filename)[1]
165
outfile = open(filename, 'wb')
167
if format == "callgrind":
168
self.calltree(outfile)
169
elif format == "txt":
170
self.pprint(file=outfile)
173
cPickle.dump(self, outfile, 2)
108
178
class _CallTreeFilter(object):
179
"""Converter of a Stats object to input suitable for KCacheGrind.
181
This code is taken from http://ddaa.net/blog/python/lsprof-calltree
182
with the changes made by J.P. Calderone and Itamar applied. Note that
183
isinstance(code, str) needs to be used at times to determine if the code
184
object is actually an external code object (with a filename, etc.) or
110
188
def __init__(self, data):
112
190
self.out_file = None
114
192
def output(self, out_file):
115
self.out_file = out_file
116
print >> out_file, 'events: Ticks'
193
self.out_file = out_file
194
out_file.write('events: Ticks\n')
117
195
self._print_summary()
118
196
for entry in self.data:
119
197
self._entry(entry)
123
201
for entry in self.data:
124
202
totaltime = int(entry.totaltime * 1000)
125
203
max_cost = max(max_cost, totaltime)
126
print >> self.out_file, 'summary: %d' % (max_cost,)
204
self.out_file.write('summary: %d\n' % (max_cost,))
128
206
def _entry(self, entry):
129
207
out_file = self.out_file
130
208
code = entry.code
131
209
inlinetime = int(entry.inlinetime * 1000)
132
#print >> out_file, 'ob=%s' % (code.co_filename,)
133
print >> out_file, 'fi=%s' % (code.co_filename,)
134
print >> out_file, 'fn=%s' % (label(code, True),)
135
print >> out_file, '%d %d' % (code.co_firstlineno, inlinetime)
210
#out_file.write('ob=%s\n' % (code.co_filename,))
211
if isinstance(code, str):
212
out_file.write('fi=~\n')
214
out_file.write('fi=%s\n' % (code.co_filename,))
215
out_file.write('fn=%s\n' % (label(code, True),))
216
if isinstance(code, str):
217
out_file.write('0 %s\n' % (inlinetime,))
219
out_file.write('%d %d\n' % (code.co_firstlineno, inlinetime))
136
220
# recursive calls are counted in entry.calls
138
222
calls = entry.calls
225
if isinstance(code, str):
228
lineno = code.co_firstlineno
141
229
for subentry in calls:
142
self._subentry(code.co_firstlineno, subentry)
230
self._subentry(lineno, subentry)
145
233
def _subentry(self, lineno, subentry):
146
234
out_file = self.out_file
147
235
code = subentry.code
148
236
totaltime = int(subentry.totaltime * 1000)
149
#print >> out_file, 'cob=%s' % (code.co_filename,)
150
print >> out_file, 'cfn=%s' % (label(code, True),)
151
print >> out_file, 'cfi=%s' % (code.co_filename,)
152
print >> out_file, 'calls=%d %d' % (
153
subentry.callcount, code.co_firstlineno)
154
print >> out_file, '%d %d' % (lineno, totaltime)
237
#out_file.write('cob=%s\n' % (code.co_filename,))
238
out_file.write('cfn=%s\n' % (label(code, True),))
239
if isinstance(code, str):
240
out_file.write('cfi=~\n')
241
out_file.write('calls=%d 0\n' % (subentry.callcount,))
243
out_file.write('cfi=%s\n' % (code.co_filename,))
244
out_file.write('calls=%d %d\n' % (
245
subentry.callcount, code.co_firstlineno))
246
out_file.write('%d %d\n' % (lineno, totaltime))