GNU Info

(python2.1-lib.info)OldProfile Class

---

Next: HotProfile Class Prev: Profiler Extensions Up: Profiler Extensions

---

Enter node , (file) or (file)node

OldProfile Class
----------------

_This is deprecated in Python 2.1.2.  This class will be removed in
Python 2.2._

The following derived profiler simulates the old style profiler,
providing errant results on recursive functions. The reason for the
usefulness of this profiler is that it runs faster (i.e., less
overhead) than the old profiler.  It still creates all the caller
stats, and is quite useful when there is _no_ recursion in the user's
code.  It is also a lot more accurate than the old profiler, as it does
not charge all its overhead time to the user's code.

     class OldProfile(Profile):
     
         def trace_dispatch_exception(self, frame, t):
             rt, rtt, rct, rfn, rframe, rcur = self.cur
             if rcur and not rframe is frame:
                 return self.trace_dispatch_return(rframe, t)
             return 0
     
         def trace_dispatch_call(self, frame, t):
             fn = `frame.f_code`
     
             self.cur = (t, 0, 0, fn, frame, self.cur)
             if self.timings.has_key(fn):
                 tt, ct, callers = self.timings[fn]
                 self.timings[fn] = tt, ct, callers
             else:
                 self.timings[fn] = 0, 0, {}
             return 1
     
         def trace_dispatch_return(self, frame, t):
             rt, rtt, rct, rfn, frame, rcur = self.cur
             rtt = rtt + t
             sft = rtt + rct
     
             pt, ptt, pct, pfn, pframe, pcur = rcur
             self.cur = pt, ptt+rt, pct+sft, pfn, pframe, pcur
     
             tt, ct, callers = self.timings[rfn]
             if callers.has_key(pfn):
                 callers[pfn] = callers[pfn] + 1
             else:
                 callers[pfn] = 1
             self.timings[rfn] = tt+rtt, ct + sft, callers
     
             return 1
     
         def snapshot_stats(self):
             self.stats = {}
             for func in self.timings.keys():
                 tt, ct, callers = self.timings[func]
                 nor_func = self.func_normalize(func)
                 nor_callers = {}
                 nc = 0
                 for func_caller in callers.keys():
                     nor_callers[self.func_normalize(func_caller)] = \
                         callers[func_caller]
                     nc = nc + callers[func_caller]
                 self.stats[nor_func] = nc, nc, tt, ct, nor_callers