Module Mtime.Span

Monotonic time spans

Time spans

type t

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-1ns.

val add : t -> t -> t

add s0 s1 is s0 + s1. Warning. Rolls over on overflow.

val abs_diff : t -> t -> t

abs_diff s0 s1 is the absolute difference between s0 and s1.

Predicates and comparisons

val equal : t -> t -> bool

equal s0 s1 is s0 = s1.

val compare : t -> t -> int

compare s0 s1 orders span by increasing duration.

val is_shorter : t -> than:t -> bool

is_shorter span ~than is true iff span lasts less than than.

val is_longer : t -> than:t -> bool

is_longer span ~than is true iff span lasts more than than.


val (*) : int -> t -> t

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-9s.

val us : t

us is a microsecond duration, 1·10-6s.

val ms : t

ms is a millisecond duration, 1·10-3s.

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 253 (~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 253 (~104 days, the largest exact floating point integer) the result is an approximation and will not round trip with of_float_ns.


val pp : t Fmt.t

pp formats with Fmt.uint64_ns_span.

val pp_ns : t Fmt.t

pp_ns ppf s prints s as an unsigned 64-bit integer nanosecond span.