package core

You can search for identifiers within the package.

in-package search v0.2.0

Industrial strength alternative to OCaml's standard library

Install

Dune Dependency

github.com Readme Changelog MIT License Edit opam file Versions (13)

Authors

J

Jane Street Group, LLC

Maintainers

J

Jane Street developers

Sources

core-v0.13.0.tar.gz

sha256=f4ceebba441f90076ac89bffc41705e2c0bc5d92b71df9100e2d1c15ea49f559

md5=0dedfb21e756427ea39ab4dc173d67a9

doc/core.time_stamp_counter/Time_stamp_counter/index.html

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:

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.

Put another way, it would not make sense to send a sexp of t from one box to another and then convert it to a Time.t, because t counts the number of cycles since reset. So the measure only makes sense in the context of a single machine.

Note that a cursory search for information about time stamp counter usage may give a false impression of its unreliability. Early processor implementations of TSC could be skewed by clock frequency changes (C-states) and by small differences between the startup time of each processor on a multi-processor machine. Modern hardware can usually be assumed to have an "invariant" tsc, and Linux has support to synchronize the initial counters at boot time when multiple processors are present.

type t = private Core_kernel.Int63.t

include Core_kernel.Bin_prot.Binable.S with type t := 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

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

include Ppx_sexp_conv_lib.Sexpable.S with type t := 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

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

val min : t -> t -> t

val max : t -> t -> 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.

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