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
13
from bzrlib import errors
11
15
__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
17
def profile(f, *args, **kwds):
30
p.enable(subcalls=True)
31
threading.setprofile(_thread_profile)
18
"""Run a function profile.
20
Exceptions are not caught: If you need stats even when exceptions are to be
21
raised, pass in a closure that will catch the exceptions and transform them
22
appropriately for your driver function.
24
Important caveat: only one profile can execute at a time. See BzrProfiler
27
:return: The functions return value and a stats object.
29
profiler = BzrProfiler()
33
32
ret = f(*args, **kwds)
36
for pp in _g_threadmap.values():
38
threading.setprofile(None)
34
stats = profiler.stop()
38
class BzrProfiler(object):
39
"""Bzr utility wrapper around Profiler.
41
for tid, pp in _g_threadmap.items():
42
threads[tid] = Stats(pp.getstats(), {})
44
return ret, Stats(p.getstats(), threads)
41
For most uses the module level 'profile()' function will be suitable.
42
However profiling when a simple wrapped function isn't available may
43
be easier to accomplish using this class.
45
To use it, create a BzrProfiler and call start() on it. Some arbitrary
46
time later call stop() to stop profiling and retrieve the statistics
47
from the code executed in the interim.
49
Note that profiling involves a threading.Lock around the actual profiling.
50
This is needed because profiling involves global manipulation of the python
51
interpreter state. As such you cannot perform multiple profiles at once.
52
Trying to do so will lock out the second profiler unless the global
53
bzrlib.lsprof.BzrProfiler.profiler_block is set to 0. Setting it to 0 will
54
cause profiling to fail rather than blocking.
58
"""Serialise rather than failing to profile concurrent profile requests."""
60
profiler_lock = threading.Lock()
61
"""Global lock used to serialise profiles."""
66
This hooks into threading and will record all calls made until
69
self._g_threadmap = {}
71
permitted = self.__class__.profiler_lock.acquire(
72
self.__class__.profiler_block)
74
raise errors.InternalBzrError(msg="Already profiling something")
76
self.p.enable(subcalls=True)
77
threading.setprofile(self._thread_profile)
79
self.__class__.profiler_lock.release()
85
This unhooks from threading and cleans up the profiler, returning
86
the gathered Stats object.
88
:return: A bzrlib.lsprof.Stats object.
92
for pp in self._g_threadmap.values():
94
threading.setprofile(None)
98
for tid, pp in self._g_threadmap.items():
99
threads[tid] = Stats(pp.getstats(), {})
100
self._g_threadmap = None
101
return Stats(p.getstats(), threads)
103
self.__class__.profiler_lock.release()
105
def _thread_profile(self, f, *args, **kwds):
106
# we lose the first profile point for a new thread in order to
107
# trampoline a new Profile object into place
108
thr = thread.get_ident()
109
self._g_threadmap[thr] = p = Profiler()
110
# this overrides our sys.setprofile hook:
111
p.enable(subcalls=True, builtins=True)
47
114
class Stats(object):
104
171
"""Output profiling data in calltree format (for KCacheGrind)."""
105
172
_CallTreeFilter(self.data).output(file)
174
def save(self, filename, format=None):
175
"""Save profiling data to a file.
177
:param filename: the name of the output file
178
:param format: 'txt' for a text representation;
179
'callgrind' for calltree format;
180
otherwise a pickled Python object. A format of None indicates
181
that the format to use is to be found from the filename. If
182
the name starts with callgrind.out, callgrind format is used
183
otherwise the format is given by the filename extension.
186
basename = os.path.basename(filename)
187
if basename.startswith('callgrind.out'):
190
ext = os.path.splitext(filename)[1]
193
outfile = open(filename, 'wb')
195
if format == "callgrind":
196
self.calltree(outfile)
197
elif format == "txt":
198
self.pprint(file=outfile)
201
cPickle.dump(self, outfile, 2)
108
206
class _CallTreeFilter(object):
207
"""Converter of a Stats object to input suitable for KCacheGrind.
209
This code is taken from http://ddaa.net/blog/python/lsprof-calltree
210
with the changes made by J.P. Calderone and Itamar applied. Note that
211
isinstance(code, str) needs to be used at times to determine if the code
212
object is actually an external code object (with a filename, etc.) or
110
216
def __init__(self, data):
112
218
self.out_file = None
114
220
def output(self, out_file):
115
self.out_file = out_file
116
print >> out_file, 'events: Ticks'
221
self.out_file = out_file
222
out_file.write('events: Ticks\n')
117
223
self._print_summary()
118
224
for entry in self.data:
119
225
self._entry(entry)
123
229
for entry in self.data:
124
230
totaltime = int(entry.totaltime * 1000)
125
231
max_cost = max(max_cost, totaltime)
126
print >> self.out_file, 'summary: %d' % (max_cost,)
232
self.out_file.write('summary: %d\n' % (max_cost,))
128
234
def _entry(self, entry):
129
235
out_file = self.out_file
130
236
code = entry.code
131
237
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)
238
#out_file.write('ob=%s\n' % (code.co_filename,))
239
if isinstance(code, str):
240
out_file.write('fi=~\n')
242
out_file.write('fi=%s\n' % (code.co_filename,))
243
out_file.write('fn=%s\n' % (label(code, True),))
244
if isinstance(code, str):
245
out_file.write('0 %s\n' % (inlinetime,))
247
out_file.write('%d %d\n' % (code.co_firstlineno, inlinetime))
136
248
# recursive calls are counted in entry.calls
138
250
calls = entry.calls
253
if isinstance(code, str):
256
lineno = code.co_firstlineno
141
257
for subentry in calls:
142
self._subentry(code.co_firstlineno, subentry)
258
self._subentry(lineno, subentry)
145
261
def _subentry(self, lineno, subentry):
146
262
out_file = self.out_file
147
263
code = subentry.code
148
264
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)
265
#out_file.write('cob=%s\n' % (code.co_filename,))
266
out_file.write('cfn=%s\n' % (label(code, True),))
267
if isinstance(code, str):
268
out_file.write('cfi=~\n')
269
out_file.write('calls=%d 0\n' % (subentry.callcount,))
271
out_file.write('cfi=%s\n' % (code.co_filename,))
272
out_file.write('calls=%d %d\n' % (
273
subentry.callcount, code.co_firstlineno))
274
out_file.write('%d %d\n' % (lineno, totaltime))