Module Core__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                      37.93ns     2.00w
      Time_ns.now                   28.18ns
      TSC.Calibrator.calibrate     115.43ns    28.00w
      TSC.now                        7.14ns
      TSC.to_time                    3.44ns     2.00w
      TSC.to_time (TSC.now ())       8.24ns     2.00w
      TSC.to_time_ns                14.20ns
      TSC.to_time_ns(TSC.now ())     9.80ns
      id                             2.91ns
      TSC.Span.of_ns                 5.81ns
      TSC.Span.to_ns                 3.70ns

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:

The conversion to Time.t depends on an estimate of the time-stamp-counter frequency. This frequency may be volatile on some systems, thereby reducing the utility of this conversion. See the Calibrator module below for details.

The captured t can only be converted to a Time.t if one also has a recently calibrated Calibrator.t from the same machine.

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

type t = private Core__.Import.Int63.t

include sig ... end

val bin_t : t Bin_prot.Type_class.t

val bin_read_t : t Bin_prot.Read.reader

val __bin_read_t__ : (int ‑> t) Bin_prot.Read.reader

val bin_reader_t : t Bin_prot.Type_class.reader

val bin_size_t : t Bin_prot.Size.sizer

val bin_write_t : t Bin_prot.Write.writer

val bin_writer_t : t Bin_prot.Type_class.writer

val bin_shape_t : Bin_prot.Shape.t

val compare : t ‑> t ‑> int

val t_of_sexp : Sexplib.Sexp.t ‑> t

val sexp_of_t : t ‑> Sexplib.Sexp.t

module Calibrator : sig ... end

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.

external now : unit ‑> t = "tsc_get"

val diff : t ‑> t ‑> Span.t

val add : t ‑> Span.t ‑> t

val to_int63 : t ‑> Core__.Import.Int63.t

val to_time : ?⁠calibrator:Calibrator.t ‑> t ‑> Core__.Import.Time.t

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

val to_time_ns : ?⁠calibrator:Calibrator.t ‑> t ‑> Core__.Import.Time_ns.t