FilesExpand file tree

 master

/

timing.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

116 lines (85 loc) · 3.96 KB

 master

/

timing.py

Copy path

Top

File metadata and controls

• Code
• Blame

116 lines (85 loc) · 3.96 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

# encoding: utf-8

"""

Utilities for timing code execution.

"""

#-----------------------------------------------------------------------------

# Copyright (C) 2008-2011 The IPython Development Team

#

# 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

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]

except ImportError:

# There is no distinction of user/system time under windows, so we just use

# time.clock() for everything...

clocku = clocks = clock = time.clock

def clock2():

"""Under windows, system CPU time can't be measured.

This just returns clock() and zero."""

return time.clock(),0.0

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:

rng = xrange(reps-1) # the last time is executed separately to store output

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]