← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lsprof.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-06-03 20:18:35 UTC
  • mfrom: (1185.82.137 w-changeset)
  • Revision ID: pqm@pqm.ubuntu.com-20060603201835-1c9a1725641ccd24
Implement bundles

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lsprof.py
4
4
# instead of just the Stats object
5
5
 
6
6
import sys
7
 
import thread
8
 
import threading
9
 
from _lsprof import Profiler, profiler_entry
 
7
from _lsprof import Profiler, profiler_entry, profiler_subentry
10
8
 
11
9
__all__ = ['profile', 'Stats']
12
10
 
13
 
_g_threadmap = {}
14
 
 
15
 
 
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
19
 
    global _g_threadmap
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)
24
 
 
25
 
 
26
11
def profile(f, *args, **kwds):
27
12
    """XXX docstring"""
28
 
    global _g_threadmap
29
13
    p = Profiler()
30
14
    p.enable(subcalls=True)
31
 
    threading.setprofile(_thread_profile)
32
15
    try:
33
16
        ret = f(*args, **kwds)
34
17
    finally:
35
18
        p.disable()
36
 
        for pp in _g_threadmap.values():
37
 
            pp.disable()
38
 
        threading.setprofile(None)
39
 
    
40
 
    threads = {}
41
 
    for tid, pp in _g_threadmap.items():
42
 
        threads[tid] = Stats(pp.getstats(), {})
43
 
    _g_threadmap = {}
44
 
    return ret, Stats(p.getstats(), threads)
 
19
    return ret,Stats(p.getstats())
45
20
 
46
21
 
47
22
class Stats(object):
48
23
    """XXX docstring"""
49
24
 
50
 
    def __init__(self, data, threads):
 
25
    def __init__(self, data):
51
26
        self.data = data
52
 
        self.threads = threads
53
27
 
54
28
    def sort(self, crit="inlinetime"):
55
29
        """XXX docstring"""
92
66
            e = self.data[i]
93
67
            if not isinstance(e.code, str):
94
68
                self.data[i] = type(e)((label(e.code),) + e[1:])
95
 
            if e.calls:
96
 
                for j in range(len(e.calls)):
97
 
                    se = e.calls[j]
98
 
                    if not isinstance(se.code, str):
99
 
                        e.calls[j] = type(se)((label(se.code),) + se[1:])
100
 
        for s in self.threads.values():
101
 
            s.freeze()
102
 
 
103
 
    def calltree(self, file):
104
 
        """Output profiling data in calltree format (for KCacheGrind)."""
105
 
        _CallTreeFilter(self.data).output(file)
106
 
 
107
 
 
108
 
class _CallTreeFilter(object):
109
 
 
110
 
    def __init__(self, data):
111
 
        self.data = data
112
 
        self.out_file = None
113
 
 
114
 
    def output(self, out_file):
115
 
        self.out_file = out_file        
116
 
        print >> out_file, 'events: Ticks'
117
 
        self._print_summary()
118
 
        for entry in self.data:
119
 
            self._entry(entry)
120
 
 
121
 
    def _print_summary(self):
122
 
        max_cost = 0
123
 
        for entry in self.data:
124
 
            totaltime = int(entry.totaltime * 1000)
125
 
            max_cost = max(max_cost, totaltime)
126
 
        print >> self.out_file, 'summary: %d' % (max_cost,)
127
 
 
128
 
    def _entry(self, entry):
129
 
        out_file = self.out_file
130
 
        code = entry.code
131
 
        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)
136
 
        # recursive calls are counted in entry.calls
137
 
        if entry.calls:
138
 
            calls = entry.calls
139
 
        else:
140
 
            calls = []
141
 
        for subentry in calls:
142
 
            self._subentry(code.co_firstlineno, subentry)
143
 
        print >> out_file
144
 
 
145
 
    def _subentry(self, lineno, subentry):
146
 
        out_file = self.out_file
147
 
        code = subentry.code
148
 
        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)
155
 
 
 
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:])
156
74
 
157
75
_fn2mod = {}
158
76
 
159
 
def label(code, calltree=False):
 
77
def label(code):
160
78
    if isinstance(code, str):
161
79
        return code
162
80
    try:
174
92
                break
175
93
        else:
176
94
            mname = _fn2mod[code.co_filename] = '<%s>'%code.co_filename
177
 
    if calltree:
178
 
        return '%s %s:%d' % (code.co_name, mname, code.co_firstlineno)
179
 
    else:
180
 
        return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
 
95
    
 
96
    return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
181
97
 
182
98
 
183
99
if __name__ == '__main__':