Module Async_kernel__.Time_source
module T1 : sig ... end
A time source has a phantom read-write parameter, where
write
gives permission to calladvance
andfire_past_alarms
.
module Read_write : sig ... end
module Id : Core_kernel.Unique_id.Id
type t
= Core_kernel.read T1.t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val id : _ T1.t -> Id.t
id t
returns a unique, consistent identifier which can be used e.g. as a map or hash table key.
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:Timing_wheel.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 towall_clock ()
returns the same value. The behavior ofnow
is special forwall_clock ()
; it always callsTime_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
forwall_clock
; it always returns the timing_wheel's notion of now.
val advance_directly : [> Core_kernel.write ] T1.t -> to_:Async_kernel__.Import.Time_ns.t -> unit
Instead of
advance_directly
, you probably should useadvance_by_alarms
.advance_directly t ~to_
advances the clock directly toto_
, whereasadvance_by_alarms
advances the clock in steps, to each intervening alarm.advance_directly
approximately determines the set of events to fire, up to timing-wheel alarm precision, whereasadvance_by_alarms
fires all alarms whose time is<= to_
. Withadvance_directly
, you must callfire_past_alarms
if you want that behavior (see docs forTiming_wheel.advance_clock
vs.Timing_wheel.fire_past_alarms
).
val advance : [> Core_kernel.write ] T1.t -> to_:Async_kernel__.Import.Time_ns.t -> unit
val advance_directly_by : [> Core_kernel.write ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> unit
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 callsadvance t
to drive the time forward in steps, where each step is the minimum ofto_
and the next alarm time. After each step,advance_by_alarms
waits for the result ofwait_for
to become determined before advancing. By default,wait_for
will beScheduler.yield ()
to allow the triggered timers to execute and potentially rearm for subsequent steps. The returned deferred is filled whento_
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 fromevery
) a chance to fire with approximately the same timing as they would live.
val advance_by_alarms_by : ?wait_for:(unit -> unit Async_kernel__.Time_source_intf.Deferred.t) -> [> Core_kernel.write ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> unit Async_kernel__.Time_source_intf.Deferred.t
advance_by_alarms_by ?wait_for t by
is equivalent to:advance_by_alarms ?wait_for t ~to_:(Time_ns.add (now t) by)
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 Async_kernel.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 Async_kernel.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 Async_kernel.Synchronous_time_source.T1.t -> 'a T1.t
Time_source
andSynchronous_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 Async_kernel.Synchronous_time_source.T1.t