package async_kernel

  1. Overview
  2. Docs
package async_kernel
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Async_kernel.Synchronous_time_sourceSource

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.

Sourcemodule T1 : sig ... end
Sourcemodule Read_write : sig ... end
Sourceval sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
Sourceval invariant_with_jobs : job: (Async_kernel__.Types.Execution_context.t, Obj.t -> unit, Obj.t) Tuple_pool.Slots.t3 Tuple_pool.Pointer.t Core_kernel.Invariant.t -> t Core_kernel.Invariant.t
include Core_kernel.Invariant.S with type t := t
Sourceval invariant : t -> unit
Sourceval 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.

Sourceval length : _ T1.t -> int

length t returns the number of alarms in the underlying Timing_wheel.

Sourceval read_only : [> Core_kernel.read ] T1.t -> t
Sourcetype callback = unit -> unit
Sourceval create : ?timing_wheel_config:Timing_wheel.Config.t -> now:Core_kernel.Time_ns.t -> unit -> Core_kernel.read_write T1.t

create ~now () creates a new time source. The default timing_wheel_config has 100 microsecond precision, with levels of >1s, >1m, >1h, >1d. The timing_wheel_config is used to tune performance; configuration does not affect the fact that alarms fire in non-decreasing time order.

Sourceval next_alarm_fires_at : [> Core_kernel.read ] T1.t -> Core_kernel.Time_ns.t option

next_alarm_fires_at t returns a time to which the clock can be advanced such that an alarm will fire, or None if t has no alarms that can ever fire.

Note that this is not necessarily the minimum such time, but it's within alarm_precision of that.

Sourceval 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.

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.

Sourceval timing_wheel_now : [> Core_kernel.read ] T1.t -> Core_kernel.Time_ns.t

Removes the special behavior of now for wall_clock (); it always returns the timing wheel's notion of now, which means that the following inequality always holds: timing_wheel_now () <= now ().

Sourceval advance_by_alarms : [> Core_kernel.write ] T1.t -> to_:Core_kernel.Time_ns.t -> unit Core_kernel.Or_error.t

advance_by_alarms t ~to_ advances t's time to to_, running callbacks for all alarms in t whose at <= to_. Callbacks run in nondecreasing order of at. If to_ <= now t, then now t does not change (and in particular does not go backward), but alarms with at <= to_ may still may fire.

Instead of advance_directly, you probably should use advance_by_alarms. advance_directly t ~to_ advances the clock directly to to_, whereas advance_by_alarms advances the clock in steps, to each intervening alarm. In particular periodic/rearming timers will fire at most twice.

run_at t at f schedules an alarm that will run f during the next subsequent advance_by_alarms t ~to_ that causes now t >= at. If at <= now t, then f will to run at the next call to advance_by_alarms. f is allowed to do all Synchronous_time_source operations except for advance_by_alarms (because f is already running during advance_by_alarms. Adding alarms is not zero-alloc and the underlying events live in the OCaml heap.

run_after t span f is run_at t (now t + span) f.

run_at_intervals t span f schedules f to run at intervals now t + k * span, for k = 0, 1, 2, etc. run_at_intervals raises if span < alarm_precision t.

Sourceval max_allowed_alarm_time : [> Core_kernel.read ] T1.t -> Core_kernel.Time_ns.t

max_allowed_alarm_time t returns the greatest at that can be supplied to add. max_allowed_alarm_time is not constant; its value increases as now t increases.

Sourcemodule Event : sig ... end
Sourceval default_timing_wheel_config : Timing_wheel.Config.t
Sourceval 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 the ASYNC_CONFIG environment variable.

Sourcemodule Expert : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct