GNU Info

(python2.1-lib.info)Calibration

---

Next: Profiler Extensions Prev: Limitations Up: Python Profiler

---

Enter node , (file) or (file)node

Calibration
===========

The profiler class has a hard coded constant that is added to each
event handling time to compensate for the overhead of calling the time
function, and socking away the results.  The following procedure can be
used to obtain this constant for a given platform (see discussion in
section Limitations above).

     import profile
     pr = profile.Profile()
     print pr.calibrate(100)
     print pr.calibrate(100)
     print pr.calibrate(100)

The argument to `calibrate()' is the number of times to try to do the
sample calls to get the CPU times.  If your computer is _very_ fast,
you might have to do:

     pr.calibrate(1000)

or even:

     pr.calibrate(10000)

The object of this exercise is to get a fairly consistent result.  When
you have a consistent answer, you are ready to use that number in the
source code.  For a Sun Sparcstation 1000 running Solaris 2.3, the
magical number is about .00053.  If you have a choice, you are better
off with a smaller constant, and your results will "less often" show up
as negative in profile statistics.

The following shows how the trace_dispatch() method in the Profile
class should be modified to install the calibration constant on a Sun
Sparcstation 1000:

     def trace_dispatch(self, frame, event, arg):
         t = self.timer()
         t = t[0] + t[1] - self.t - .00053 # Calibration constant
     
         if self.dispatch[event](frame,t):
             t = self.timer()
             self.t = t[0] + t[1]
         else:
             r = self.timer()
             self.t = r[0] + r[1] - t # put back unrecorded delta
         return

Note that if there is no calibration constant, then the line containing
the callibration constant should simply say:

     t = t[0] + t[1] - self.t  # no calibration constant

You can also achieve the same results using a derived class (and the
profiler will actually run equally fast!!), but the above method is the
simplest to use.  I could have made the profiler "self calibrating,"
but it would have made the initialization of the profiler class slower,
and would have required some _very_ fancy coding, or else the use of a
variable where the constant `.00053' was placed in the code shown.
This is a *VERY* critical performance section, and there is no reason
to use a variable lookup at this point, when a constant can be used.