timing.py
123 lines
| 4.1 KiB
| text/x-python
|
PythonLexer
|
r2498 | # encoding: utf-8 | ||
""" | ||||
Utilities for timing code execution. | ||||
""" | ||||
#----------------------------------------------------------------------------- | ||||
|
r5390 | # Copyright (C) 2008-2011 The IPython Development Team | ||
|
r2498 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
import time | ||||
#----------------------------------------------------------------------------- | ||||
# Code | ||||
#----------------------------------------------------------------------------- | ||||
# If possible (Unix), use the resource module instead of time.clock() | ||||
try: | ||||
import resource | ||||
|
r26644 | except ImportError: | ||
resource = None | ||||
# Some implementations (like jyputerlite) don't have getrusage | ||||
|
r26645 | if resource is not None and hasattr(resource, "getrusage"): | ||
|
r2498 | def clocku(): | ||
"""clocku() -> floating point number | ||||
Return the *USER* CPU time in seconds since the start of the process. | ||||
This is done via a call to resource.getrusage, so it avoids the | ||||
wraparound problems in time.clock().""" | ||||
return resource.getrusage(resource.RUSAGE_SELF)[0] | ||||
def clocks(): | ||||
"""clocks() -> floating point number | ||||
Return the *SYSTEM* CPU time in seconds since the start of the process. | ||||
This is done via a call to resource.getrusage, so it avoids the | ||||
wraparound problems in time.clock().""" | ||||
return resource.getrusage(resource.RUSAGE_SELF)[1] | ||||
def clock(): | ||||
"""clock() -> floating point number | ||||
Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of | ||||
the process. This is done via a call to resource.getrusage, so it | ||||
avoids the wraparound problems in time.clock().""" | ||||
u,s = resource.getrusage(resource.RUSAGE_SELF)[:2] | ||||
return u+s | ||||
def clock2(): | ||||
"""clock2() -> (t_user,t_system) | ||||
Similar to clock(), but return a tuple of user/system times.""" | ||||
return resource.getrusage(resource.RUSAGE_SELF)[:2] | ||||
|
r26647 | |||
|
r26646 | else: | ||
|
r2498 | # There is no distinction of user/system time under windows, so we just use | ||
|
r24660 | # time.perff_counter() for everything... | ||
|
r24659 | clocku = clocks = clock = time.perf_counter | ||
|
r2498 | def clock2(): | ||
"""Under windows, system CPU time can't be measured. | ||||
|
r24660 | This just returns perf_counter() and zero.""" | ||
|
r24659 | return time.perf_counter(),0.0 | ||
|
r2498 | |||
def timings_out(reps,func,*args,**kw): | ||||
"""timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output) | ||||
Execute a function reps times, return a tuple with the elapsed total | ||||
CPU time in seconds, the time per call and the function's output. | ||||
Under Unix, the return value is the sum of user+system time consumed by | ||||
the process, computed via the resource module. This prevents problems | ||||
related to the wraparound effect which the time.clock() function has. | ||||
Under Windows the return value is in wall clock seconds. See the | ||||
documentation for the time module for more details.""" | ||||
reps = int(reps) | ||||
assert reps >=1, 'reps must be >= 1' | ||||
if reps==1: | ||||
start = clock() | ||||
out = func(*args,**kw) | ||||
tot_time = clock()-start | ||||
else: | ||||
|
r23036 | rng = range(reps-1) # the last time is executed separately to store output | ||
|
r2498 | start = clock() | ||
for dummy in rng: func(*args,**kw) | ||||
out = func(*args,**kw) # one last time | ||||
tot_time = clock()-start | ||||
av_time = tot_time / reps | ||||
return tot_time,av_time,out | ||||
def timings(reps,func,*args,**kw): | ||||
"""timings(reps,func,*args,**kw) -> (t_total,t_per_call) | ||||
Execute a function reps times, return a tuple with the elapsed total CPU | ||||
time in seconds and the time per call. These are just the first two values | ||||
in timings_out().""" | ||||
return timings_out(reps,func,*args,**kw)[0:2] | ||||
def timing(func,*args,**kw): | ||||
"""timing(func,*args,**kw) -> t_total | ||||
Execute a function once, return the elapsed total CPU time in | ||||
seconds. This is just the first value in timings_out().""" | ||||
return timings_out(1,func,*args,**kw)[0] | ||||