← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lsprof.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

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