Logo

Programming-Idioms

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

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations
(time (foo))
#include <chrono>
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();
using System.Diagnostics;
var stopwatch = new Stopwatch();
stopwatch.Start();
foo();
stopwatch.Stop();
var t = stopwatch.ElapsedMilliseconds;
import std.datetime;
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
import "time"
t1 := time.Now()
foo()
t := time.Since(t1)
ns := int64(t / time.Nanosecond)
fmt.Printf("%dns\n", ns)
import "time"
t1 := time.Now()
foo()
t := time.Since(t1)
ns := t.Nanoseconds()
fmt.Printf("%dns\n", ns)
console.time('foo');
foo();
console.timeEnd('foo');
long t = System.nanoTime();
foo();
t = System.nanoTime() - t;
System.out.println(t + "ns");
import static java.lang.System.nanoTime;
import static java.lang.System.out;
long t = nanoTime();
foo();
out.println(nanoTime() - t);
(time (foo))
$start = hrtime(true);
foo();
$end = hrtime(true);
$t = $end - $start;
echo $t;
uses sysutils;
var
  t1, t: QWord;
begin
  t1 := GetTickCount64;
  foo;
  t := (GetTickCount64 - t1) * 1000000;
  writeln(t);
end.
use Benchmark qw(:hireswallclock timediff);
sub foo {};
my $start = Benchmark->new;
foo;
my $t = timediff(Benchmark->new, $start)->[0] * 10**9; 
import time
t1 = time.perf_counter_ns()
foo()
t2 = time.perf_counter_ns()
print('Nanoseconds:', t2 - t1)
t1 = Time.now
foo
p (Time.now - t1)*1000000
use std::time::{Duration, Instant};
let start = Instant::now();
foo();
let duration = start.elapsed();
println!("{}", duration);