Lines Matching refs:self
48 def __init__(self, profiler):
49 self.profiler = profiler
51 def run(self, statement, filename, sort):
52 prof = self.profiler()
58 self._show(prof, filename, sort)
60 def runctx(self, statement, globals, locals, filename, sort):
61 prof = self.profiler()
67 self._show(prof, filename, sort)
69 def _show(self, prof, filename, sort):
106 self.cur is always a tuple. Each such tuple corresponds to a stack
107 frame that is currently active (self.cur[-2]). The following are the
127 self.timings[]. The index is always the name stored in self.cur[-3].
144 def __init__(self, timer=None, bias=None):
145 self.timings = {}
146 self.cur = None
147 self.cmd = ""
148 self.c_func_name = ""
151 bias = self.bias
152 self.bias = bias # Materialize in local dict for lookup speed.
155 self.timer = self.get_time = time.process_time
156 self.dispatcher = self.trace_dispatch_i
158 self.timer = timer
159 t = self.timer() # test out timer function
163 self.get_time = timer
164 self.dispatcher = self.trace_dispatch_i
167 self.dispatcher = self.trace_dispatch
169 self.dispatcher = self.trace_dispatch_l
177 self.get_time = get_time_timer
178 self.t = self.get_time()
179 self.simulate_call('profiler')
183 def trace_dispatch(self, frame, event, arg):
184 timer = self.timer
186 t = t[0] + t[1] - self.t - self.bias
189 self.c_func_name = arg.__name__
191 if self.dispatch[event](self, frame,t):
193 self.t = t[0] + t[1]
196 self.t = r[0] + r[1] - t # put back unrecorded delta
201 def trace_dispatch_i(self, frame, event, arg):
202 timer = self.timer
203 t = timer() - self.t - self.bias
206 self.c_func_name = arg.__name__
208 if self.dispatch[event](self, frame, t):
209 self.t = timer()
211 self.t = timer() - t # put back unrecorded delta
216 def trace_dispatch_mac(self, frame, event, arg):
217 timer = self.timer
218 t = timer()/60.0 - self.t - self.bias
221 self.c_func_name = arg.__name__
223 if self.dispatch[event](self, frame, t):
224 self.t = timer()/60.0
226 self.t = timer()/60.0 - t # put back unrecorded delta
230 def trace_dispatch_l(self, frame, event, arg):
231 get_time = self.get_time
232 t = get_time() - self.t - self.bias
235 self.c_func_name = arg.__name__
237 if self.dispatch[event](self, frame, t):
238 self.t = get_time()
240 self.t = get_time() - t # put back unrecorded delta
242 # In the event handlers, the first 3 elements of self.cur are unpacked
245 # _pt self.cur[0] "parent time" time to be charged to parent frame
246 # _it self.cur[1] "internal time" time spent directly in the function
247 # _et self.cur[2] "external time" time spent in subfunctions
249 def trace_dispatch_exception(self, frame, t):
250 rpt, rit, ret, rfn, rframe, rcur = self.cur
252 return self.trace_dispatch_return(rframe, t)
253 self.cur = rpt, rit+t, ret, rfn, rframe, rcur
257 def trace_dispatch_call(self, frame, t):
258 if self.cur and frame.f_back is not self.cur[-2]:
259 rpt, rit, ret, rfn, rframe, rcur = self.cur
264 self.trace_dispatch_return(rframe, 0)
265 assert (self.cur is None or \
266 frame.f_back is self.cur[-2]), ("Bad call",
267 self.cur[-3])
270 self.cur = (t, 0, 0, fn, frame, self.cur)
271 timings = self.timings
279 def trace_dispatch_c_call (self, frame, t):
280 fn = ("", 0, self.c_func_name)
281 self.cur = (t, 0, 0, fn, frame, self.cur)
282 timings = self.timings
290 def trace_dispatch_return(self, frame, t):
291 if frame is not self.cur[-2]:
292 assert frame is self.cur[-2].f_back, ("Bad return", self.cur[-3])
293 self.trace_dispatch_return(self.cur[-2], 0)
298 rpt, rit, ret, rfn, frame, rcur = self.cur
303 self.cur = ppt, pit + rpt, pet + frame_total, pfn, pframe, pcur
305 timings = self.timings
338 # The next few functions play with self.cmd. By carefully preloading
341 # We use self.cmd as that string, and the resulting stats look
344 def set_cmd(self, cmd):
345 if self.cur[-1]: return # already set
346 self.cmd = cmd
347 self.simulate_call(cmd)
350 def __init__(self, filename, line, name):
351 self.co_filename = filename
352 self.co_line = line
353 self.co_name = name
354 self.co_firstlineno = 0
356 def __repr__(self):
357 return repr((self.co_filename, self.co_line, self.co_name))
360 def __init__(self, code, prior):
361 self.f_code = code
362 self.f_back = prior
364 def simulate_call(self, name):
365 code = self.fake_code('profile', 0, name)
366 if self.cur:
367 pframe = self.cur[-2]
370 frame = self.fake_frame(code, pframe)
371 self.dispatch['call'](self, frame, 0)
374 # timings for self.cmd frame.
376 def simulate_cmd_complete(self):
377 get_time = self.get_time
378 t = get_time() - self.t
379 while self.cur[-1]:
382 self.dispatch['return'](self, self.cur[-2], t)
384 self.t = get_time() - t
387 def print_stats(self, sort=-1):
389 pstats.Stats(self).strip_dirs().sort_stats(sort). \
392 def dump_stats(self, file):
394 self.create_stats()
395 marshal.dump(self.stats, f)
397 def create_stats(self):
398 self.simulate_cmd_complete()
399 self.snapshot_stats()
401 def snapshot_stats(self):
402 self.stats = {}
403 for func, (cc, ns, tt, ct, callers) in self.timings.items():
408 self.stats[func] = cc, nc, tt, ct, callers
414 def run(self, cmd):
417 return self.runctx(cmd, dict, dict)
419 def runctx(self, cmd, globals, locals):
420 self.set_cmd(cmd)
421 sys.setprofile(self.dispatcher)
426 return self
429 def runcall(self, func, /, *args, **kw):
430 self.set_cmd(repr(func))
431 sys.setprofile(self.dispatcher)
478 def calibrate(self, m, verbose=0):
479 if self.__class__ is not Profile:
482 saved_bias = self.bias
483 self.bias = 0
485 return self._calibrate_inner(m, verbose)
487 self.bias = saved_bias
489 def _calibrate_inner(self, m, verbose):
490 get_time = self.get_time