Time a function: Difference between revisions

{{task|Programming environment operations}}

 

 

This task is intended as a subtask for [[Measure relative performance of sorting algorithms implementations]].

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

 

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.");

===Example===

Identity(4) takes 0.000001117 seconds.

Sum(4) takes: 0.000003632 seconds.

=={{header|AutoHotkey}}==

===System time===

Uses system time, not process time

Return

 

%function%(parameter)

Return ElapsedTime := A_TickCount - StartTime . " milliseconds"

 

=={{header|C}}==

On some system (like GNU/Linux) to be able to use the <tt>clock_gettime</tt> function you must link with the <tt>rt</tt> (RealTime) library.

 

#include <time.h>

 

}

 

/* this one should be appropriate to avoid errors on multiprocessors systems */

 

double time_it(int (*action)(int), int arg)

printf("sum (4) takes %lf s\n", time_it(sum, 4));

return 0;

 

=={{header|C sharp|C#}}==

Using Stopwatch.

 

using System.Linq;

using System.Threading;

Enumerable.Range(1, 10000).Where(x => x % 2 == 0).Sum(); // Sum even numers from 1 to 10000

}

 

Using DateTime.

 

using System.Linq;

using System.Threading;

Enumerable.Range(1, 10000).Where(x => x % 2 == 0).Sum(); // Sum even numers from 1 to 10000

}

 

Output:

 

 

=={{header|Common Lisp}}==

Common Lisp provides a standard utility for performance measurement, [http://www.lispworks.com/documentation/HyperSpec/Body/m_time.htm time]:

 

Evaluation took:

0.151 seconds of real time

0 calls to %EVAL

0 page faults and

 

(The example output here is from [[SBCL]].)

The functions [http://www.lispworks.com/documentation/HyperSpec/Body/f_get__1.htm get-internal-run-time] and [http://www.lispworks.com/documentation/HyperSpec/Body/f_get_in.htm get-internal-real-time] may be used to get time information programmatically, with at least one-second granularity (and usually more). Here is a function which uses them to measure the time taken for one execution of a provided function:

 

(let ((real-base (get-internal-real-time))

(run-base (get-internal-run-time)))

CL-USER> (timings (lambda () (reduce #'+ (make-list 100000 :initial-element 1))))

17/500

 

=={{header|D}}==

import tango.io.Stdout;

import tango.time.Clock;

Stdout.format("Sum(4) takes {:f6} seconds",timeIt(&sum,4)).newline;

}

 

=={{header|E}}==

{{trans|Java}} — E has no ''standardized'' facility for CPU time measurement; this {{works with|E-on-Java}}.

 

println("Counting...")

for _ in 1..x {}

def finish := threadMX.getCurrentThreadCpuTime()

println(`Counting to $count takes ${(finish-start)//1000000}ms`)

 

=={{header|Factor}}==

<pre>

Running time: 0.002888635 seconds

=={{header|Forth}}==

{{works with|GNU Forth}}

utime 2>R ' EXECUTE

utime 2R> D-

<# # # # # # # [CHAR] . HOLD #S #> TYPE ." seconds" ;

 

 

=={{header|Haskell}}==

 

-- We assume the function we are timing is an IO monad computation

timeIt :: (Fractional c) => (a -> IO b) -> a -> IO c

 

-- Version for use with evaluating regular non-monadic functions

 

===Example===

 

=={{header|HicEst}}==

SYSTEM(WAIT = 1234) ! wait 1234 milliseconds

t_end = TIME()

 

 

=={{header|Ioke}}==

 

func = method((1..50000) reduce(+))

 

 

=={{header|J}}==

===Example===

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.lang.management.ThreadMXBean;

 

System.out.println("Done!");

}

 

Measures real time rather than CPU time:

{{works with|Java|(all versions)}}

 

long start, end;

start = System.currentTimeMillis();

System.out.println("Counting to 1000000000 takes "+(end-start)+"ms");

 

Output:

<pre>Counting...

Done!

Counting...

Done!

 

=={{header|Logo}}==

This is not an ideal method; Logo does not expose a timer (except for the WAIT command) so we use the Unix "date" command to get a second timer.

 

output first first shell "|date +%s|

end

end

 

 

where x is an operation. Example calculating a million digits of Sqrt[3]:

First elements if the time in seconds, second elements if the result from the operation. Note that I truncated the result.

 

=={{header|OCaml}}==

let start_time = Sys.time () in

ignore (action arg);

let finish_time = Sys.time () in

 

===Example===

Sum(4) takes 0.084005 seconds.

- : unit = ()

 

=={{header|Oz}}==

%% returns milliseconds

fun {TimeIt Proc}

{FoldL {List.number 1 1000000 1} Number.'+' 4 _}

end}

 

=={{header|Perl}}==

Example of using the built-in Benchmark core module - it compares two versions of recursive factorial functions:

use Memoize;

 

'fac2' => sub { fac2(50) },

});

Output:

 

Example without using Benchmark:

my ($user,$system,$cuser,$csystem) = times;

$user + $system

 

printf "Sum(4) takes %f seconds.\n", time_it(\&sum, 4);

 

=={{header|PL/I}}==

 

start_time = secs();

 

/* Note: using the SECS function takes into account the clock */

 

 

 

=={{header|PureBasic}}==

===Built in timer===

This version uses the built in timer, on Windows it has an accuracy of ~10-15 msec.

Protected i, palindromic, String$

For i=0 To Limit

PrintN("and "+Str(cnt)+" are palindromic.")

Print("Press ENTER to exit."): Input()

===Hi-res version===

{{libheader|Droopy}}

 

This version uses a hi-res timer, but it is Windows only.

Define Timed.f, cnt

PrintN("Starting timing of a calculation,")

PrintN("and "+Str(cnt)+" are palindromic.")

Print("Press ENTER to exit."): Input()

 

 

This version still relies on the Windows API but does not make use of any additional libraries.

Static maxfreq.q

Protected T.q

PrintN("and " + Str(cnt) + " are palindromic.")

Print("Press ENTER to exit."): Input()

Sample output:

 

=={{header|Python}}==

 

'''Note:''' There is an overhead in executing a function that does nothing.

def usec(function, arguments):

modname, funcname = __name__, function.__name__

raise

 

 

===Example===

1.7

2.2

3.3

[2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0]

 

=={{header|R}}==

R has a built-in function, system.time, to calculate this.

foo <- function()

{

timer <- system.time(foo())

# Extract the processing time

For a breakdown of processing time by function, there is Rprof.

foo()

Rprof(NULL)

 

=={{header|Ruby}}==

Ruby's Benchmark module provides a way to generate nice reports (numbers are in seconds):

 

Benchmark.bm(8) do |x|

x.report("nothing:") { }

x.report("sum:") { (1..1_000_000).inject(4) {|sum, x| sum + x} }

Output:

<pre>

</pre>

 

 

=={{header|Scheme}}==

 

=={{header|Standard ML}}==

val timer = Timer.startCPUTimer ()

val _ = action arg

in

Time.+ (#usr times, #sys times)

 

===Example===

Sum(4) takes 0.220 seconds.

val it = () : unit

 

=={{header|Tcl}}==

for {set i 1; set sum 0.0} {$i <= $n} {incr i} {set sum [expr {$sum + $i}]}

return [expr {wide($sum)}]

 

puts [time {sum_n 1e6} 100]

 

=={{header|UNIX Shell}}==

 

sys 0m0.006s