← 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-08-24 21:05:09 UTC
  • mto: This revision was merged to the branch mainline in revision 4645.
  • Revision ID: robertc@robertcollins.net-20090824210509-pproia2q9evq1nsl
lsprof support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lsprof.py
13
13
 
14
14
__all__ = ['profile', 'Stats']
15
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
16
def profile(f, *args, **kwds):
30
17
    """Run a function profile.
31
18
 
32
19
    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.
 
20
    raised, pass in a closure that will catch the exceptions and transform them
 
21
    appropriately for your driver function.
35
22
 
36
23
    :return: The functions return value and a stats object.
37
24
    """
38
 
    global _g_threadmap
39
 
    p = Profiler()
40
 
    p.enable(subcalls=True)
41
 
    threading.setprofile(_thread_profile)
 
25
    profiler = BzrProfiler()
 
26
    profiler.start()
42
27
    try:
43
28
        ret = f(*args, **kwds)
44
29
    finally:
45
 
        p.disable()
46
 
        for pp in _g_threadmap.values():
 
30
        stats = profiler.stop()
 
31
    return ret, stats
 
32
 
 
33
 
 
34
class BzrProfiler(object):
 
35
    """Bzr utility wrapper around Profiler.
 
36
    
 
37
    For most uses the module level 'profile()' function will be suitable.
 
38
    However profiling when a simple wrapped function isn't available may
 
39
    be easier to accomplish using this class.
 
40
 
 
41
    To use it, create a BzrProfiler and call start() on it. Some arbitrary
 
42
    time later call stop() to stop profiling and retrieve the statistics
 
43
    from the code executed in the interim.
 
44
    """
 
45
 
 
46
    def start(self):
 
47
        """Start profiling.
 
48
        
 
49
        This hooks into threading and will record all calls made until
 
50
        stop() is called.
 
51
        """
 
52
        self._g_threadmap = {}
 
53
        self.p = Profiler()
 
54
        self.p.enable(subcalls=True)
 
55
        threading.setprofile(self._thread_profile)
 
56
 
 
57
    def stop(self):
 
58
        """Stop profiling.
 
59
 
 
60
        This unhooks from threading and cleans up the profiler, returning
 
61
        the gathered Stats object.
 
62
 
 
63
        :return: A bzrlib.lsprof.Stats object.
 
64
        """
 
65
        self.p.disable()
 
66
        for pp in self._g_threadmap.values():
47
67
            pp.disable()
48
68
        threading.setprofile(None)
 
69
        p = self.p
 
70
        self.p = None
 
71
        threads = {}
 
72
        for tid, pp in self._g_threadmap.items():
 
73
            threads[tid] = Stats(pp.getstats(), {})
 
74
        self._g_threadmap = None
 
75
        return Stats(p.getstats(), threads)
49
76
 
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)
 
77
    def _thread_profile(self, f, *args, **kwds):
 
78
        # we lose the first profile point for a new thread in order to
 
79
        # trampoline a new Profile object into place
 
80
        thr = thread.get_ident()
 
81
        self._g_threadmap[thr] = p = Profiler()
 
82
        # this overrides our sys.setprofile hook:
 
83
        p.enable(subcalls=True, builtins=True)
55
84
 
56
85
 
57
86
class Stats(object):