`Mtime.Span`

Monotonic time spans

The type for non-negative monotonic time spans.

They represent the difference between two monotonic clock readings with nanosecond precision (1e-9s) and can measure up to approximatevely 584 Julian year spans before silently rolling over (unlikely since this is in a single program run).

`val zero : t`

`zero`

is a span of 0ns.

`val one : t`

`one`

is a span of 1ns.

`val max_span : t`

`max_span`

is a span of `2^64-1`

ns.

`n * dur`

is `n`

times duration `n`

. Does not check for overflow or that `n`

is positive.

`val ns : t`

`ns`

is a nanosecond duration, 1·10^{-9}s.

`val us : t`

`us`

is a microsecond duration, 1·10^{-6}s.

`val ms : t`

`ms`

is a millisecond duration, 1·10^{-3}s.

`val s : t`

`s`

is a second duration, 1s.

`val min : t`

`min`

is a minute duration, 60s.

`val hour : t`

`hour`

is an hour duration, 3600s.

`val day : t`

`day`

is a day duration, 86'400s.

`val year : t`

`year`

is a Julian year duration (365.25 days), 31'557'600s.

`val to_uint64_ns : t -> int64`

`to_uint64_ns s`

is `s`

as an *unsigned* 64-bit integer nanosecond span.

`val of_uint64_ns : int64 -> t`

`of_uint64_ns u`

is the *unsigned* 64-bit integer nanosecond span `u`

as a span.

`val of_float_ns : float -> t option`

`of_float_ns f`

is the positive floating point nanosecond span `f`

as a span. This is `None`

if `f`

is negative, non finite, or larger or equal than 2^{53} (~104 days, the largest exact floating point integer).

`val to_float_ns : t -> float`

`to_float_ns s`

is `span`

as a nanosecond floating point span. Note that if `s`

is larger than 2^{53} (~104 days, the largest exact floating point integer) the result is an approximation and will not round trip with `of_float_ns`

.

`pp`

formats with `Fmt.uint64_ns_span`

.