Module `Async_kernel.Time_source`

module T1 : sig ... end: A time source has a phantom read-write parameter, where write gives permission to call advance and fire_past_alarms.

module Read_write : sig ... end

type t = Core_kernel.read T1.t

val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t

include Core_kernel.Invariant.S with type t := t

type t

val invariant : t Base__.Invariant_intf.inv

val invariant_with_jobs : job:Async_kernel__.Job.t Core_kernel.Invariant.t -> t Core_kernel.Invariant.t
val read_only : [> Core_kernel.read ] T1.t -> t
val create : ?⁠timing_wheel_config:Core_kernel.Timing_wheel_ns.Config.t -> now:Async_kernel__.Import.Time_ns.t -> unit -> Core_kernel.read_write T1.t
val wall_clock : unit -> t: A time source with now t given by wall-clock time (i.e., Time_ns.now) and that is advanced automatically as time passes (specifically, at the start of each Async cycle). There is only one wall-clock time source; every call to wall_clock () returns the same value. The behavior of now is special for wall_clock (); it always calls Time_ns.now (), so it can return times that the time source has not yet been advanced to.

val alarm_precision : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t
val next_alarm_fires_at : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t option
val now : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t
val timing_wheel_now : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t: Removes the special behavior of now for wall_clock; it always returns the timing_wheel's notion of now.

val advance : [> Core_kernel.write ] T1.t -> to_:Async_kernel__.Import.Time_ns.t -> unit: Unlike in Synchronous_time_source, the advance function here only approximately determines the set of events to fire. You should also call fire_past_alarms if you want precision (see docs for Timing_wheel_ns.advance_clock vs. Timing_wheel_ns.fire_past_alarms).

val advance_by : [> Core_kernel.write ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> unit

val fire_past_alarms : [> Core_kernel.write ] T1.t -> unit

val advance_by_alarms : ?⁠wait_for:(unit -> unit Async_kernel__.Time_source_intf.Deferred.t) -> [> Core_kernel.write ] T1.t -> to_:Async_kernel__.Import.Time_ns.t -> unit Async_kernel__.Time_source_intf.Deferred.t

advance_by_alarms t repeatedly calls advance t to drive the time forward in steps, where each step is the minimum of to_ and the next alarm time. After each step, advance_by_alarms waits for the result of wait_for to become determined before advancing. By default, wait_for will be Scheduler.yield () to allow the triggered timers to execute and potentially rearm for subsequent steps. The returned deferred is filled when to_ is reached.

advance_by_alarms is useful in simulation when one wants to efficiently advance to a time in the future while giving periodic timers (e.g., resulting from every) a chance to fire with approximately the same timing as they would live.

module Continue : sig ... end

val run_repeatedly : ?⁠start:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠continue_on_error:bool -> ?⁠finished:unit Ivar.t -> [> Core_kernel.read ] T1.t -> f:(unit -> unit Async_kernel__.Time_source_intf.Deferred.t) -> continue:Continue.t -> unit: See Clock.every for documentation.

val run_at : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t -> ('a -> unit) -> 'a -> unit
val run_after : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> ('a -> unit) -> 'a -> unit
val at : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t -> unit Async_kernel__.Time_source_intf.Deferred.t
val after : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> unit Async_kernel__.Time_source_intf.Deferred.t
val with_timeout : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> 'a Async_kernel__.Time_source_intf.Deferred.t -> [ `Timeout | `Result of 'a ] Async_kernel__.Time_source_intf.Deferred.t

module Event : sig ... end

val at_varying_intervals : ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> [> Core_kernel.read ] T1.t -> (unit -> Async_kernel__.Import.Time_ns.Span.t) -> unit Async_kernel__.Async_stream.t
val at_intervals : ?⁠start:Async_kernel__.Import.Time_ns.t -> ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> unit Async_kernel__.Async_stream.t
val every' : ?⁠start:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠continue_on_error:bool -> ?⁠finished:unit Ivar.t -> [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> (unit -> unit Async_kernel__.Time_source_intf.Deferred.t) -> unit: See Clock.every' for documentation.

val every : ?⁠start:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠continue_on_error:bool -> [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> (unit -> unit) -> unit
val run_at_intervals' : ?⁠start:Async_kernel__.Import.Time_ns.t -> ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠continue_on_error:bool -> [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> (unit -> unit Async_kernel__.Time_source_intf.Deferred.t) -> unit
val run_at_intervals : ?⁠start:Async_kernel__.Import.Time_ns.t -> ?⁠stop:unit Async_kernel__.Time_source_intf.Deferred.t -> ?⁠continue_on_error:bool -> [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> (unit -> unit) -> unit
val of_synchronous : 'a Synchronous_time_source.T1.t -> 'a T1.t: Time_source and Synchronous_time_source are the same data structure and use the same underlying timing wheel. The types are freely interchangeable.

val to_synchronous : 'a T1.t -> 'a Synchronous_time_source.T1.t