Module Async_kernel.Synchronous_time_source
A synchronous version of Async_kernel.Time_source
. advance_by_alarms
runs alarms immediately, rather than enqueueing Async jobs.
Synchronous_time_source
is a wrapper around Timing_wheel
. One difference is that Synchronous_time_source
alarms fire in non-decreasing time order, whereas in Timing_wheel
that is only true for alarms in different time intervals as determined by alarm_precision
.
module T1 : sig ... end
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 invariant_with_jobs : job:Async_kernel__.Job.t Core_kernel.Invariant.t -> t Core_kernel.Invariant.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 length : _ T1.t -> int
length t
returns the number of alarms in the underlyingTiming_wheel
.
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
create ~now ()
creates a new time source. The defaulttiming_wheel_config
has 100 microsecond precision, with levels of >1s, >1m, >1h, >1d. Thetiming_wheel_config
is used to tune performance; configuration does not affect the fact that alarms fire in non-decreasing time order.
val alarm_precision : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t
val is_wall_clock : [> Core_kernel.read ] T1.t -> bool
is_wall_clock
reports whether this time source represents 'wall clock' time, or some alternate source of time.
val now : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t
The behavior of
now
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 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, which means that the following inequality always holds:timing_wheel_now () <= now ()
.
val advance_by_alarms : [> Core_kernel.write ] T1.t -> to_:Async_kernel__.Import.Time_ns.t -> unit Core_kernel.Or_error.t
advance_by_alarms t ~to_
advancest
's time toto_
, running callbacks for all alarms int
whoseat <= to_
. Callbacks run in nondecreasing order ofat
. Ifto_ <= now t
, thennow t
does not change (and in particular does not go backward), but alarms withat <= to_
may still may fire.
val advance_directly : [> Core_kernel.write ] T1.t -> to_:Async_kernel__.Import.Time_ns.t -> unit Core_kernel.Or_error.t
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. In particular periodic/rearming timers will fire at most twice.
val run_at : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t -> callback -> unit
run_at t at f
schedules an alarm that will runf
during the next subsequentadvance_by_alarms t ~to_
that causesnow t >= at
. Ifat <= now t
, thenf
will to run at the next call toadvance_by_alarms
.f
is allowed to do allSynchronous_time_source
operations except foradvance_by_alarms
(becausef
is already running duringadvance_by_alarms
. Adding alarms is not zero-alloc and the underlying events live in the OCaml heap.
val run_after : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> callback -> unit
run_after t span f
isrun_at t (now t + span) f
.
val run_at_intervals : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> callback -> unit
run_at_intervals t span f
schedulesf
to run at intervalsnow t + k * span
, for k = 0, 1, 2, etc.run_at_intervals
raises ifspan < alarm_precision t
.
val max_allowed_alarm_time : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t
max_allowed_alarm_time t
returns the greatestat
that can be supplied toadd
.max_allowed_alarm_time
is not constant; its value increases asnow t
increases.
module Event : sig ... end
val default_timing_wheel_config : Timing_wheel.Config.t
val wall_clock : unit -> t
A time source with
now t
given by wall-clock time (i.e.Time_ns.now
), and automatically advanced at the start of each Async cycle. The wall clock uses the same timing wheel as that used by the Async scheduler, and is hence similarly affected by theASYNC_CONFIG
environment variable.