## 10.8.1 OldProfile Class

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