Logo

Programming-Idioms

  • Go
  • Python

Idiom #125 Measure function call duration

measure the duration t, in nanoseconds, of a call to the function foo. Print this duration.

import time
t1 = time.perf_counter_ns()
foo()
t2 = time.perf_counter_ns()
print('Nanoseconds:', t2 - t1)

t1 and t2 are int
import "time"
t1 := time.Now()
foo()
t := time.Since(t1)
ns := int64(t / time.Nanosecond)
fmt.Printf("%dns\n", ns)

t1 has type time.Time.
t has type time.Duration.
import "time"
t1 := time.Now()
foo()
t := time.Since(t1)
ns := t.Nanoseconds()
fmt.Printf("%dns\n", ns)

t1 has type time.Time.
t has type time.Duration.
ns has type int64.
(time (foo))

time prints time elapsed, but in ms
New implementation...
< > ⌨
JPSII 
t1 = time.perf_counter_ns()
foo()
t2 = time.perf_counter_ns()
print('Nanoseconds:', t2 - t1)
t1 := time.Now()
foo()
t := time.Since(t1)
ns := int64(t / time.Nanosecond)
fmt.Printf("%dns\n", ns)
t1 := time.Now()
foo()
t := time.Since(t1)
ns := t.Nanoseconds()
fmt.Printf("%dns\n", ns)
(time (foo))
auto start = std::chrono::steady_clock::now();
foo();
auto end = std::chrono::steady_clock::now();
auto t = std::chrono::duration_cast<std::chrono::nanoseconds>(end-start).count();
var stopwatch = new Stopwatch();
stopwatch.Start();
foo();
stopwatch.Stop();
var t = stopwatch.ElapsedMilliseconds;
StopWatch sw;
sw.start;
foo;
auto t = sw.peek.nsecs; 
writeln(t);

var t = Stopwatch();
t.start();
foo();
t.stop();
print(t.elapsedMicroseconds * 1000);
def main(function) do
  function
  |> :timer.tc()
  |> elem(0)
  |> Kernel.*(1_000)
end
timer:tc(Fun).
integer, parameter :: i8 = selected_int_kind(15)
integer (kind=i8) :: count, count_rate, count_2
x = 1.2
call system_clock (count, count_rate)
call foo
call system_clock (count_2)
if (count_rate == 10**9) then
  print *,"The call to foo used ", (count_2-count), "Nanoseconds"
else
  print *,"The call to foo used ", (count_2-count)/real(count_rate)*1e9, "Nanoseconds"
end if

console.time('foo');
foo();
console.timeEnd('foo');
long t = System.nanoTime();
foo();
t = System.nanoTime() - t;
System.out.println(t + "ns");
long t = nanoTime();
foo();
out.println(nanoTime() - t);
(time (foo))
$start = hrtime(true);
foo();
$end = hrtime(true);
$t = $end - $start;
echo $t;

var
  t1, t: QWord;
begin
  t1 := GetTickCount64;
  foo;
  t := (GetTickCount64 - t1) * 1000000;
  writeln(t);
end.
sub foo {};
my $start = Benchmark->new;
foo;
my $t = timediff(Benchmark->new, $start)->[0] * 10**9; 

t1 = Time.now
foo
p (Time.now - t1)*1000000
let start = Instant::now();
foo();
let duration = start.elapsed();
println!("{}", duration);