/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/lsprof.py

  • Committer: Robert Collins
  • Date: 2005-10-19 10:11:57 UTC
  • mfrom: (1185.16.78)
  • mto: This revision was merged to the branch mainline in revision 1470.
  • Revision ID: robertc@robertcollins.net-20051019101157-17438d311e746b4f
merge from upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/lsprof.py
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
5
 
 
6
 
from __future__ import absolute_import
7
 
 
8
 
import codecs
9
 
try:
10
 
    import cPickle as pickle
11
 
except ImportError:
12
 
    import pickle
13
 
import operator
14
 
import os
15
 
import sys
16
 
try:
17
 
    import _thread
18
 
except ImportError:
19
 
    import thread as _thread
20
 
import threading
21
 
from _lsprof import Profiler, profiler_entry
22
 
 
23
 
from . import errors
24
 
 
25
 
__all__ = ['profile', 'Stats']
26
 
 
27
 
 
28
 
def profile(f, *args, **kwds):
29
 
    """Run a function profile.
30
 
 
31
 
    Exceptions are not caught: If you need stats even when exceptions are to be
32
 
    raised, pass in a closure that will catch the exceptions and transform them
33
 
    appropriately for your driver function.
34
 
 
35
 
    Important caveat: only one profile can execute at a time. See BzrProfiler
36
 
    for details.
37
 
 
38
 
    :return: The functions return value and a stats object.
39
 
    """
40
 
    profiler = BzrProfiler()
41
 
    profiler.start()
42
 
    try:
43
 
        ret = f(*args, **kwds)
44
 
    finally:
45
 
        stats = profiler.stop()
46
 
    return ret, stats
47
 
 
48
 
 
49
 
class BzrProfiler(object):
50
 
    """Bzr utility wrapper around Profiler.
51
 
 
52
 
    For most uses the module level 'profile()' function will be suitable.
53
 
    However profiling when a simple wrapped function isn't available may
54
 
    be easier to accomplish using this class.
55
 
 
56
 
    To use it, create a BzrProfiler and call start() on it. Some arbitrary
57
 
    time later call stop() to stop profiling and retrieve the statistics
58
 
    from the code executed in the interim.
59
 
 
60
 
    Note that profiling involves a threading.Lock around the actual profiling.
61
 
    This is needed because profiling involves global manipulation of the python
62
 
    interpreter state. As such you cannot perform multiple profiles at once.
63
 
    Trying to do so will lock out the second profiler unless the global
64
 
    breezy.lsprof.BzrProfiler.profiler_block is set to 0. Setting it to 0 will
65
 
    cause profiling to fail rather than blocking.
66
 
    """
67
 
 
68
 
    profiler_block = 1
69
 
    """Serialise rather than failing to profile concurrent profile requests."""
70
 
 
71
 
    profiler_lock = threading.Lock()
72
 
    """Global lock used to serialise profiles."""
73
 
 
74
 
    def start(self):
75
 
        """Start profiling.
76
 
 
77
 
        This hooks into threading and will record all calls made until
78
 
        stop() is called.
79
 
        """
80
 
        self._g_threadmap = {}
81
 
        self.p = Profiler()
82
 
        permitted = self.__class__.profiler_lock.acquire(
83
 
            self.__class__.profiler_block)
84
 
        if not permitted:
85
 
            raise errors.InternalBzrError(msg="Already profiling something")
86
 
        try:
87
 
            self.p.enable(subcalls=True)
88
 
            threading.setprofile(self._thread_profile)
89
 
        except BaseException:
90
 
            self.__class__.profiler_lock.release()
91
 
            raise
92
 
 
93
 
    def stop(self):
94
 
        """Stop profiling.
95
 
 
96
 
        This unhooks from threading and cleans up the profiler, returning
97
 
        the gathered Stats object.
98
 
 
99
 
        :return: A breezy.lsprof.Stats object.
100
 
        """
101
 
        try:
102
 
            self.p.disable()
103
 
            for pp in self._g_threadmap.values():
104
 
                pp.disable()
105
 
            threading.setprofile(None)
106
 
            p = self.p
107
 
            self.p = None
108
 
            threads = {}
109
 
            for tid, pp in self._g_threadmap.items():
110
 
                threads[tid] = Stats(pp.getstats(), {})
111
 
            self._g_threadmap = None
112
 
            return Stats(p.getstats(), threads)
113
 
        finally:
114
 
            self.__class__.profiler_lock.release()
115
 
 
116
 
    def _thread_profile(self, f, *args, **kwds):
117
 
        # we lose the first profile point for a new thread in order to
118
 
        # trampoline a new Profile object into place
119
 
        thr = _thread.get_ident()
120
 
        self._g_threadmap[thr] = p = Profiler()
121
 
        # this overrides our sys.setprofile hook:
122
 
        p.enable(subcalls=True, builtins=True)
123
 
 
124
 
 
125
 
class Stats(object):
126
 
    """Wrapper around the collected data.
127
 
 
128
 
    A Stats instance is created when the profiler finishes. Normal
129
 
    usage is to use save() to write out the data to a file, or pprint()
130
 
    to write human-readable information to the command line.
131
 
    """
132
 
 
133
 
    def __init__(self, data, threads):
134
 
        self.data = data
135
 
        self.threads = threads
136
 
 
137
 
    def sort(self, crit="inlinetime", reverse=True):
138
 
        """Sort the data by the supplied critera.
139
 
 
140
 
        :param crit: the data attribute used as the sort key."""
141
 
        if crit not in profiler_entry.__dict__ or crit == 'code':
142
 
            raise ValueError("Can't sort by %s" % crit)
143
 
 
144
 
        key_func = operator.attrgetter(crit)
145
 
        self.data.sort(key=key_func, reverse=reverse)
146
 
 
147
 
        for e in self.data:
148
 
            if e.calls:
149
 
                e.calls.sort(key=key_func, reverse=reverse)
150
 
 
151
 
    def pprint(self, top=None, file=None):
152
 
        """Pretty-print the data as plain text for human consumption.
153
 
 
154
 
        :param top: only output the top n entries.
155
 
            The default value of None means output all data.
156
 
        :param file: the output file; if None, output will
157
 
            default to stdout."""
158
 
        if file is None:
159
 
            file = sys.stdout
160
 
        d = self.data
161
 
        if top is not None:
162
 
            d = d[:top]
163
 
        cols = "% 12s %12s %11.4f %11.4f   %s\n"
164
 
        hcols = "% 12s %12s %12s %12s %s\n"
165
 
        file.write(hcols % ("CallCount", "Recursive", "Total(ms)",
166
 
                            "Inline(ms)", "module:lineno(function)"))
167
 
        for e in d:
168
 
            file.write(cols % (e.callcount, e.reccallcount, e.totaltime,
169
 
                               e.inlinetime, label(e.code)))
170
 
            if e.calls:
171
 
                for se in e.calls:
172
 
                    file.write(cols % ("+%s" % se.callcount, se.reccallcount,
173
 
                                       se.totaltime, se.inlinetime,
174
 
                                       "+%s" % label(se.code)))
175
 
 
176
 
    def freeze(self):
177
 
        """Replace all references to code objects with string
178
 
        descriptions; this makes it possible to pickle the instance."""
179
 
 
180
 
        # this code is probably rather ickier than it needs to be!
181
 
        for i in range(len(self.data)):
182
 
            e = self.data[i]
183
 
            if not isinstance(e.code, str):
184
 
                self.data[i] = type(e)((label(e.code),) + e[1:])
185
 
            if e.calls:
186
 
                for j in range(len(e.calls)):
187
 
                    se = e.calls[j]
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():
191
 
            s.freeze()
192
 
 
193
 
    def calltree(self, file):
194
 
        """Output profiling data in calltree format (for KCacheGrind)."""
195
 
        _CallTreeFilter(self.data).output(file)
196
 
 
197
 
    def save(self, filename, format=None):
198
 
        """Save profiling data to a file.
199
 
 
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.
207
 
        """
208
 
        if format is None:
209
 
            basename = os.path.basename(filename)
210
 
            if basename.startswith('callgrind.out'):
211
 
                format = "callgrind"
212
 
            else:
213
 
                ext = os.path.splitext(filename)[1]
214
 
                if len(ext) > 1:
215
 
                    format = ext[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))
224
 
            else:
225
 
                self.freeze()
226
 
                pickle.dump(self, outfile, 2)
227
 
 
228
 
 
229
 
class _CallTreeFilter(object):
230
 
    """Converter of a Stats object to input suitable for KCacheGrind.
231
 
 
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
236
 
    a Python built-in.
237
 
    """
238
 
 
239
 
    def __init__(self, data):
240
 
        self.data = data
241
 
        self.out_file = None
242
 
 
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:
248
 
            self._entry(entry)
249
 
 
250
 
    def _print_summary(self):
251
 
        max_cost = 0
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,))
256
 
 
257
 
    def _entry(self, entry):
258
 
        out_file = self.out_file
259
 
        code = entry.code
260
 
        inlinetime = int(entry.inlinetime * 1000)
261
 
        if isinstance(code, str):
262
 
            out_file.write('fi=~\n')
263
 
        else:
264
 
            out_file.write('fi=%s\n' % (code.co_filename,))
265
 
        out_file.write('fn=%s\n' % (label(code, True),))
266
 
        if isinstance(code, str):
267
 
            out_file.write('0  %s\n' % (inlinetime,))
268
 
        else:
269
 
            out_file.write('%d %d\n' % (code.co_firstlineno, inlinetime))
270
 
        # recursive calls are counted in entry.calls
271
 
        if entry.calls:
272
 
            calls = entry.calls
273
 
        else:
274
 
            calls = []
275
 
        if isinstance(code, str):
276
 
            lineno = 0
277
 
        else:
278
 
            lineno = code.co_firstlineno
279
 
        for subentry in calls:
280
 
            self._subentry(lineno, subentry)
281
 
        out_file.write('\n')
282
 
 
283
 
    def _subentry(self, lineno, subentry):
284
 
        out_file = self.out_file
285
 
        code = subentry.code
286
 
        totaltime = int(subentry.totaltime * 1000)
287
 
        if isinstance(code, str):
288
 
            out_file.write('cfi=~\n')
289
 
            out_file.write('cfn=%s\n' % (label(code, True),))
290
 
            out_file.write('calls=%d 0\n' % (subentry.callcount,))
291
 
        else:
292
 
            out_file.write('cfi=%s\n' % (code.co_filename,))
293
 
            out_file.write('cfn=%s\n' % (label(code, True),))
294
 
            out_file.write('calls=%d %d\n' % (
295
 
                subentry.callcount, code.co_firstlineno))
296
 
        out_file.write('%d %d\n' % (lineno, totaltime))
297
 
 
298
 
 
299
 
_fn2mod = {}
300
 
 
301
 
 
302
 
def label(code, calltree=False):
303
 
    if isinstance(code, str):
304
 
        return code
305
 
    try:
306
 
        mname = _fn2mod[code.co_filename]
307
 
    except KeyError:
308
 
        for k, v in sys.modules.items():
309
 
            if v is None:
310
 
                continue
311
 
            if getattr(v, '__file__', None) is None:
312
 
                continue
313
 
            if not isinstance(v.__file__, str):
314
 
                continue
315
 
            if v.__file__.startswith(code.co_filename):
316
 
                mname = _fn2mod[code.co_filename] = k
317
 
                break
318
 
        else:
319
 
            mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename
320
 
    if calltree:
321
 
        return '%s %s:%d' % (code.co_name, mname, code.co_firstlineno)
322
 
    else:
323
 
        return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
324
 
 
325
 
 
326
 
def main():
327
 
    sys.argv = sys.argv[1:]
328
 
    if not sys.argv:
329
 
        sys.stderr.write("usage: lsprof.py <script> <arguments...>\n")
330
 
        sys.exit(2)
331
 
    import runpy
332
 
    result, stats = profile(runpy.run_path, sys.argv[0], run_name='__main__')
333
 
    stats.sort()
334
 
    stats.pprint()
335
 
 
336
 
 
337
 
if __name__ == '__main__':
338
 
    main()