Module Time_stamp_counter

High-performance timing.

This module provides the fast function now () which is our best effort high-performance cycle counter for a given platform. For x86 systems this retrieves the CPU's internal time stamp counter using the RDTSC instruction. For systems that do not have a RDTSC instruction, we fallback to using clock_gettime(CLOCK_MONOTONIC).

Here is a benchmark of execution time in nanos and allocations in words:

      Name                         Time/Run   mWd/Run
     ---------------------------- ---------- ---------
      Time.now                      27.99ns     2.00w
      Time_ns.now                   25.21ns
      TSC.Calibrator.calibrate      68.61ns
      TSC.now                        6.87ns
      TSC.to_time                    4.30ns     2.00w
      TSC.to_time (TSC.now ())       8.75ns     2.00w
      TSC.to_time_ns                 4.70ns
      TSC.to_time_ns(TSC.now ())     9.56ns
      id                             2.86ns
      TSC.Span.of_ns                11.66ns
      TSC.Span.to_ns                 3.84ns

Type t is an Int63.t and consequently has no allocation overhead (on 64-bit machines), unlike Time.now () which returns a boxed float.

Functions are also provided to estimate the relationship of CPU time-stamp-counter frequency to real time, thereby allowing one to convert from t to Time.t. There are some caveats to this that are worth noting:

See also: http://en.wikipedia.org/wiki/Time_Stamp_Counter

type t = private Core_kernel.Int63.t
include Bin_prot.Binable.S with type t := t
type t
include Bin_prot.Binable.S_only_functions with type t := t
type t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
val compare : t -> t -> int
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
type t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Core_kernel.Comparisons.S with type t := t
include Core_kernel.Comparisons.Infix
type t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
module Calibrator : sig ... end with type tsc := t

A calibrator contains a snapshot of machine-specific information that is used to convert between TSC values and clock time. This information needs to be calibrated periodically such that it stays updated w.r.t. changes in the CPU's time-stamp-counter frequency, which can vary depending on load, heat, etc. (Also see the comment in the .ml file.)

module Span : sig ... end

Span indicates some integer number of cycles.

val now : unit -> t
val diff : t -> t -> Span.t
val add : t -> Span.t -> t
val to_int63 : t -> Core_kernel.Int63.t
val zero : t
val calibrator : Calibrator.t Core_kernel.Lazy.t

A default calibrator for the current process. Most programs can just use this calibrator; use others if collecting data from other processes / machines.

The first time this lazy value is forced, it spends approximately 3ms calibrating.

While the Async scheduler is running, this value is recalibrated regularly.

val to_time : t -> calibrator:Calibrator.t -> Core_kernel.Time.t

It is guaranteed that repeated calls will return nondecreasing Time.t values.

val to_time_ns : t -> calibrator:Calibrator.t -> Core_kernel.Time_ns.t