← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lsprof.py

  • Committer: Robert Collins
  • Date: 2009-05-14 09:42:07 UTC
  • mto: This revision was merged to the branch mainline in revision 4362.
  • Revision ID: robertc@robertcollins.net-20090514094207-a0pqfjtw4oujd86m
Add bug info.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
import cPickle
 
7
import os
 
8
import sys
 
9
import thread
 
10
import threading
 
11
from _lsprof import Profiler, profiler_entry
 
12
 
 
13
 
 
14
__all__ = ['profile', 'Stats']
 
15
 
 
16
_g_threadmap = {}
 
17
 
 
18
 
 
19
def _thread_profile(f, *args, **kwds):
 
20
    # we lose the first profile point for a new thread in order to trampoline
 
21
    # a new Profile object into place
 
22
    global _g_threadmap
 
23
    thr = thread.get_ident()
 
24
    _g_threadmap[thr] = p = Profiler()
 
25
    # this overrides our sys.setprofile hook:
 
26
    p.enable(subcalls=True, builtins=True)
 
27
 
 
28
 
 
29
def profile(f, *args, **kwds):
 
30
    """Run a function profile.
 
31
 
 
32
    Exceptions are not caught: If you need stats even when exceptions are to be
 
33
    raised, passing in a closure that will catch the exceptions and transform
 
34
    them appropriately for your driver function.
 
35
 
 
36
    :return: The functions return value and a stats object.
 
37
    """
 
38
    global _g_threadmap
 
39
    p = Profiler()
 
40
    p.enable(subcalls=True)
 
41
    threading.setprofile(_thread_profile)
 
42
    try:
 
43
        ret = f(*args, **kwds)
 
44
    finally:
 
45
        p.disable()
 
46
        for pp in _g_threadmap.values():
 
47
            pp.disable()
 
48
        threading.setprofile(None)
 
49
 
 
50
    threads = {}
 
51
    for tid, pp in _g_threadmap.items():
 
52
        threads[tid] = Stats(pp.getstats(), {})
 
53
    _g_threadmap = {}
 
54
    return ret, Stats(p.getstats(), threads)
 
55
 
 
56
 
 
57
class Stats(object):
 
58
    """XXX docstring"""
 
59
 
 
60
    def __init__(self, data, threads):
 
61
        self.data = data
 
62
        self.threads = threads
 
63
 
 
64
    def sort(self, crit="inlinetime"):
 
65
        """XXX docstring"""
 
66
        if crit not in profiler_entry.__dict__:
 
67
            raise ValueError, "Can't sort by %s" % crit
 
68
        self.data.sort(lambda b, a: cmp(getattr(a, crit),
 
69
                                        getattr(b, crit)))
 
70
        for e in self.data:
 
71
            if e.calls:
 
72
                e.calls.sort(lambda b, a: cmp(getattr(a, crit),
 
73
                                              getattr(b, crit)))
 
74
 
 
75
    def pprint(self, top=None, file=None):
 
76
        """XXX docstring"""
 
77
        if file is None:
 
78
            file = sys.stdout
 
79
        d = self.data
 
80
        if top is not None:
 
81
            d = d[:top]
 
82
        cols = "% 12s %12s %11.4f %11.4f   %s\n"
 
83
        hcols = "% 12s %12s %12s %12s %s\n"
 
84
        cols2 = "+%12s %12s %11.4f %11.4f +  %s\n"
 
85
        file.write(hcols % ("CallCount", "Recursive", "Total(ms)",
 
86
                            "Inline(ms)", "module:lineno(function)"))
 
87
        for e in d:
 
88
            file.write(cols % (e.callcount, e.reccallcount, e.totaltime,
 
89
                               e.inlinetime, label(e.code)))
 
90
            if e.calls:
 
91
                for se in e.calls:
 
92
                    file.write(cols % ("+%s" % se.callcount, se.reccallcount,
 
93
                                       se.totaltime, se.inlinetime,
 
94
                                       "+%s" % label(se.code)))
 
95
 
 
96
    def freeze(self):
 
97
        """Replace all references to code objects with string
 
98
        descriptions; this makes it possible to pickle the instance."""
 
99
 
 
100
        # this code is probably rather ickier than it needs to be!
 
101
        for i in range(len(self.data)):
 
102
            e = self.data[i]
 
103
            if not isinstance(e.code, str):
 
104
                self.data[i] = type(e)((label(e.code),) + e[1:])
 
105
            if e.calls:
 
106
                for j in range(len(e.calls)):
 
107
                    se = e.calls[j]
 
108
                    if not isinstance(se.code, str):
 
109
                        e.calls[j] = type(se)((label(se.code),) + se[1:])
 
110
        for s in self.threads.values():
 
111
            s.freeze()
 
112
 
 
113
    def calltree(self, file):
 
114
        """Output profiling data in calltree format (for KCacheGrind)."""
 
115
        _CallTreeFilter(self.data).output(file)
 
116
 
 
117
    def save(self, filename, format=None):
 
118
        """Save profiling data to a file.
 
119
 
 
120
        :param filename: the name of the output file
 
121
        :param format: 'txt' for a text representation;
 
122
            'callgrind' for calltree format;
 
123
            otherwise a pickled Python object. A format of None indicates
 
124
            that the format to use is to be found from the filename. If
 
125
            the name starts with callgrind.out, callgrind format is used
 
126
            otherwise the format is given by the filename extension.
 
127
        """
 
128
        if format is None:
 
129
            basename = os.path.basename(filename)
 
130
            if basename.startswith('callgrind.out'):
 
131
                format = "callgrind"
 
132
            else:
 
133
                ext = os.path.splitext(filename)[1]
 
134
                if len(ext) > 1:
 
135
                    format = ext[1:]
 
136
        outfile = open(filename, 'wb')
 
137
        try:
 
138
            if format == "callgrind":
 
139
                self.calltree(outfile)
 
140
            elif format == "txt":
 
141
                self.pprint(file=outfile)
 
142
            else:
 
143
                self.freeze()
 
144
                cPickle.dump(self, outfile, 2)
 
145
        finally:
 
146
            outfile.close()
 
147
 
 
148
 
 
149
class _CallTreeFilter(object):
 
150
    """Converter of a Stats object to input suitable for KCacheGrind.
 
151
 
 
152
    This code is taken from http://ddaa.net/blog/python/lsprof-calltree
 
153
    with the changes made by J.P. Calderone and Itamar applied. Note that
 
154
    isinstance(code, str) needs to be used at times to determine if the code
 
155
    object is actually an external code object (with a filename, etc.) or
 
156
    a Python built-in.
 
157
    """
 
158
 
 
159
    def __init__(self, data):
 
160
        self.data = data
 
161
        self.out_file = None
 
162
 
 
163
    def output(self, out_file):
 
164
        self.out_file = out_file
 
165
        out_file.write('events: Ticks\n')
 
166
        self._print_summary()
 
167
        for entry in self.data:
 
168
            self._entry(entry)
 
169
 
 
170
    def _print_summary(self):
 
171
        max_cost = 0
 
172
        for entry in self.data:
 
173
            totaltime = int(entry.totaltime * 1000)
 
174
            max_cost = max(max_cost, totaltime)
 
175
        self.out_file.write('summary: %d\n' % (max_cost,))
 
176
 
 
177
    def _entry(self, entry):
 
178
        out_file = self.out_file
 
179
        code = entry.code
 
180
        inlinetime = int(entry.inlinetime * 1000)
 
181
        #out_file.write('ob=%s\n' % (code.co_filename,))
 
182
        if isinstance(code, str):
 
183
            out_file.write('fi=~\n')
 
184
        else:
 
185
            out_file.write('fi=%s\n' % (code.co_filename,))
 
186
        out_file.write('fn=%s\n' % (label(code, True),))
 
187
        if isinstance(code, str):
 
188
            out_file.write('0  %s\n' % (inlinetime,))
 
189
        else:
 
190
            out_file.write('%d %d\n' % (code.co_firstlineno, inlinetime))
 
191
        # recursive calls are counted in entry.calls
 
192
        if entry.calls:
 
193
            calls = entry.calls
 
194
        else:
 
195
            calls = []
 
196
        if isinstance(code, str):
 
197
            lineno = 0
 
198
        else:
 
199
            lineno = code.co_firstlineno
 
200
        for subentry in calls:
 
201
            self._subentry(lineno, subentry)
 
202
        out_file.write('\n')
 
203
 
 
204
    def _subentry(self, lineno, subentry):
 
205
        out_file = self.out_file
 
206
        code = subentry.code
 
207
        totaltime = int(subentry.totaltime * 1000)
 
208
        #out_file.write('cob=%s\n' % (code.co_filename,))
 
209
        out_file.write('cfn=%s\n' % (label(code, True),))
 
210
        if isinstance(code, str):
 
211
            out_file.write('cfi=~\n')
 
212
            out_file.write('calls=%d 0\n' % (subentry.callcount,))
 
213
        else:
 
214
            out_file.write('cfi=%s\n' % (code.co_filename,))
 
215
            out_file.write('calls=%d %d\n' % (
 
216
                subentry.callcount, code.co_firstlineno))
 
217
        out_file.write('%d %d\n' % (lineno, totaltime))
 
218
 
 
219
_fn2mod = {}
 
220
 
 
221
def label(code, calltree=False):
 
222
    if isinstance(code, str):
 
223
        return code
 
224
    try:
 
225
        mname = _fn2mod[code.co_filename]
 
226
    except KeyError:
 
227
        for k, v in sys.modules.items():
 
228
            if v is None:
 
229
                continue
 
230
            if getattr(v, '__file__', None) is None:
 
231
                continue
 
232
            if not isinstance(v.__file__, str):
 
233
                continue
 
234
            if v.__file__.startswith(code.co_filename):
 
235
                mname = _fn2mod[code.co_filename] = k
 
236
                break
 
237
        else:
 
238
            mname = _fn2mod[code.co_filename] = '<%s>'%code.co_filename
 
239
    if calltree:
 
240
        return '%s %s:%d' % (code.co_name, mname, code.co_firstlineno)
 
241
    else:
 
242
        return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
 
243
 
 
244
 
 
245
if __name__ == '__main__':
 
246
    import os
 
247
    sys.argv = sys.argv[1:]
 
248
    if not sys.argv:
 
249
        sys.stderr.write("usage: lsprof.py <script> <arguments...>\n")
 
250
        sys.exit(2)
 
251
    sys.path.insert(0, os.path.abspath(os.path.dirname(sys.argv[0])))
 
252
    stats = profile(execfile, sys.argv[0], globals(), locals())
 
253
    stats.sort()
 
254
    stats.pprint()