Add the Timers module to measure real-time and cpu-time

This code is based on the `google/benchmarks` repository.

- `realtime` is a monotonic high-resolution clock provided by the kernel.
  In most cases this is equivalent to `time_ns` in `Base`.
- `cputime` is the time that the process was actually running on a processor.
  This excludes time spend in the kernel and time spend descheduled.

The `Timers` module includes a fair-amount of platform specific code so the
implementation is split between a generic *unix* implementation based on the
high-resoltion clocked provided through `clock_gettime`. On *darwin* prior to
10.12.0 the kernel only provides `CLOCK_MONOTONIC` making it less useful and
we have to fallback onto `getRUsage`.

We intentional don't do error handling for the timer calls. Which may or may
not be a wise choice.

Author: vchuravy

src/BenchmarkTools.jl

@@ -12,6 +12,12 @@ end
 
 const BENCHMARKTOOLS_VERSION = v"0.2.2"
 
+##########
+# Timers #
+##########
+
+include("timers/timers.jl")
+
 ##############
 # Parameters #
 ##############
@@ -26,7 +32,9 @@ export loadparams!
 
 include("trials.jl")
 
-export gctime,
+export realtime,
+       cputime,
+       gctime,
        memory,
        allocs,
        params,

src/timers/darwin.jl

@@ -0,0 +1,42 @@
+const RUSAGE_SELF = Cint(0)
+const RUSAGE_CHILDREN = Cint(-1)
+
+struct TimeVal
+    tv_sec::Clong
+    tv_usec::Clong
+end
+
+struct RUsage
+    ru_utime::TimeVal
+    ru_stime::TimeVal
+    ru_maxrss::Clong
+    ru_ixrss::Clong
+    ru_idrss::Clong
+    ru_isrss::Clong
+    ru_minflt::Clong
+    ru_majflt::Clong
+    ru_nswap::Clong
+    ru_inblock::Clong
+    ru_outblock::Clong
+    ru_msgsnd::Clong
+    ru_msgrcv::Clong
+    ru_nsignals::Clong
+    ru_nvcsw::Clong
+    ru_nivcsw::Clong
+end
+
+@inline function maketime(ru::RUsage)
+    user   = ru.ru_utime.tv_sec * 1e9 + ru.ru_utime.tv_usec *1e3
+    kernel = ru.ru_stime.tv_sec * 1e9 + ru.ru_stime.tv_usec *1e3
+    return user+kernel
+end
+
+@inline function realtime()
+    Float64(Base.time_ns())
+end
+
+@inline function cputime()
+    ru = Ref{RUsage}()
+    ccall(:getRUsage, Cint, (Cint, Ref{RUsage}), RUSAGE_SELF, ru)
+    return maketime(ru[])
+end

src/timers/timers.jl

@@ -0,0 +1,39 @@
+#=
+Based upon https://github.com/google/benchmark
+=#
+
+module Timers
+import Compat
+
+"""
+    realtime()
+
+Monotonic runtime counter
+
+Returns time in ns as Float64.
+"""
+function realtime end
+
+"""
+    cputime()
+
+Process specific CPU time clock.
+
+Returns time in ns as Float64.
+"""
+function cputime end
+
+function _applever()
+    return VersionNumber(readchomp(`sw_vers -productVersion`))
+end
+
+if Compat.Sys.isapple() && _applever() < v"10.12.0"
+    include("darwin.jl")
+elseif Compat.Sys.isunix()
+    include("unix.jl")
+elseif Compat.Sys.iswindows()
+    include("windows.jl")
+else
+    error("$(Sys.KERNEL) is not supported please file an issue")
+end
+end # module 

src/timers/unix.jl

@@ -0,0 +1,38 @@
+struct TimeSpec
+    tv_sec  :: UInt64 # time_t
+    tv_nsec :: UInt64
+end
+
+maketime(ts) = ts.tv_sec * 1e9 + ts.tv_nsec
+
+# From bits/times.h on a Linux system
+# Check if those are the same on BSD
+if Compat.Sys.islinux()
+    const CLOCK_MONOTONIC          = Cint(1)
+    const CLOCK_PROCESS_CPUTIME_ID = Cint(2)
+elseif Sys.KERNEL == :FreeBSD # atleast on FreeBSD 11.1
+    const CLOCK_MONOTONIC          = Cint(4)
+    const CLOCK_PROCESS_CPUTIME_ID = Cint(14)
+elseif Compat.Sys.isapple() # Version 10.12 required
+    const CLOCK_MONOTONIC          = Cint(6)
+    const CLOCK_PROCESS_CPUTIME_ID = Cint(12)
+else
+    error("""
+          BenchmarkTools doesn't currently support your operating system.
+          Please file an issue, your kernel is $(Sys.KERNEL)
+          """)
+end
+
+@inline function clock_gettime(cid)
+    ts = Ref{TimeSpec}()
+    ccall(:clock_gettime, Cint, (Cint, Ref{TimeSpec}), cid, ts)
+    return ts[]
+end
+
+@inline function realtime()
+    maketime(clock_gettime(CLOCK_MONOTONIC))
+end
+
+@inline function cputime()
+    maketime(clock_gettime(CLOCK_PROCESS_CPUTIME_ID))
+end

src/timers/windows.jl

@@ -0,0 +1,33 @@
+"""
+    FileTime
+
+See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724284(v=vs.85).aspx
+"""
+struct FileTime
+    dwHighDateTime::UInt32
+    dwLowDateTime::UInt32
+end
+
+const HANDLE = Ptr{Void}
+
+@inline function maketime(kernel_time::FileTime, user_time::FileTime)
+    kernel = (kernel_time.dwHighDateTime % UInt64) << 32 | kernel_time.dwLowDateTime
+    user   = (  user_time.dwHighDateTime % UInt64) << 32 |   user_time.dwLowDateTime
+    (kernel + user) * 1e2
+end
+
+@inline function realtime()
+    return Float64(Base.time_ns())
+end
+
+@inline function cputime()
+    proc = ccall(:GetCurrentProcess, HANDLE, ())
+    creation_time = Ref{FileTime}()
+    exit_time = Ref{FileTime}()
+    kernel_time = Ref{FileTime}()
+    user_time = Ref{FileTime}()
+
+    ccall(:GetProccessTimes, Cint, (HANDLE, Ref{FileTime}, Ref{FileTime}, Ref{FileTime}, Ref{FileTime}),
+                                proc, creation_time, exit_time, kernel_time, user_time)
+    return maketime(kernel_time, user_time)
+end