Time a function: Difference between revisions
(→Example: Substituted simpler example, at suggestion of Roger Hui.) |
m (→{{header|Python}}: Wasn't that silly?) |
||
Line 51: | Line 51: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
'''Interpreter:''' [[Python]] |
|||
[[Category:Python]] |
|||
Given ''function'' and ''arguments'' return a time (in microseconds) it takes to make the call. |
Given ''function'' and ''arguments'' return a time (in microseconds) it takes to make the call. |
||
Revision as of 20:32, 19 February 2008
You are encouraged to solve this task according to the task description, using any language you may know.
What time does it take to execute a `function' with a given `arguments'.
Use a timer with the least granularity available on your system.
What caveats are there?
This task is intended as a subtask for Measure relative performance of sorting algorithms implementations.
Ada
with Ada.Calendar; use Ada.Calendar; with Ada.Text_Io; use Ada.Text_Io; procedure Query_Performance is type Proc_Access is access procedure(X : in out Integer); function Time_It(Action : Proc_Access; Arg : Integer) return Duration is Start_Time : Time := Clock; Finis_Time : Time; Func_Arg : Integer := Arg; begin Action(Func_Arg); Finis_Time := Clock; return Finis_Time - Start_Time; end Time_It; procedure Identity(X : in out Integer) is begin X := X; end Identity; procedure Sum (Num : in out Integer) is begin for I in 1..1000 loop Num := Num + I; end loop; end Sum; Id_Access : Proc_Access := Identity'access; Sum_Access : Proc_Access := Sum'access; begin Put_Line("Identity(4) takes" & Duration'Image(Time_It(Id_Access, 4)) & " seconds."); Put_Line("Sum(4) takes:" & Duration'Image(Time_It(Sum_Access, 4)) & " seconds."); end Query_Performance;
Example
Identity(4) takes 0.000001117 seconds. Sum(4) takes: 0.000003632 seconds.
J
Time and space requirements are tested using verbs obtained through the Foreign conjunction (!:). 6!:2 returns time required for execution, in floating-point measurement of seconds. 7!:2 returns a measurement of space required to execute. Both receive as input a sentence for execution.
When the Memoize feature or similar techniques are used, execution time and space can both be affected by prior calculations.
Example
(6!:2,7!:2) '|: 50 50 50 $ i. 50^3' 0.00387912 1.57414e6
Python
Given function and arguments return a time (in microseconds) it takes to make the call.
Note: There is an overhead in executing a function that does nothing.
import sys, timeit def usec(function, arguments): modname, funcname = __name__, function.__name__ timer = timeit.Timer(stmt='%(funcname)s(*args)' % vars(), setup='from %(modname)s import %(funcname)s; args=%(arguments)r' % vars()) try: t, N = 0, 1 while t < 0.2: t = min(timer.repeat(repeat=3, number=N)) N *= 10 microseconds = round(10000000 * t / N, 1) # per loop return microseconds except: timer.print_exc(file=sys.stderr) raise
def nothing(): pass def identity(x): return x
Example
>>> print usec(nothing, []) 1.7 >>> print usec(identity, [1]) 2.2 >>> print usec(pow, (2, 100)) 3.3 >>> print map(lambda n: str(usec(qsort, (range(n),))), range(10)) ['2.7', '2.8', '31.4', '38.1', '58.0', '76.2', '100.5', '130.0', '149.3', '180.0']
where qsort() implemented on Quicksort page. Timings show that the implementation of qsort() has quadratic dependence on sequence length N for already sorted sequences (instead of O(N*log(N)) in average).