Module Timing_wheel
val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t
type 'a timing_wheel
= 'a t
type 'a t_now
= 'a t
<:sexp_of< _ t_now >>
displays onlynow t
, not all the alarms.
val sexp_of_t_now : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t_now -> Ppx_sexp_conv_lib.Sexp.t
module Alarm : sig ... end
include Core_kernel.Invariant.S1 with type 'a t := 'a t
val invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
module Level_bits : sig ... end
module Config : sig ... end
val create : config:Config.t -> start:Core_kernel.Time_ns.t -> 'a t
create ~config ~start
creates a new timing wheel with current timestart
.create
raises ifstart < Time_ns.epoch
. For a fixedlevel_bits
, a smaller (i.e. more precise)alarm_precision
decreases the representable range of times/keys and increases the constant factor foradvance_clock
.
val alarm_precision : _ t -> Core_kernel.Time_ns.Span.t
Accessors
val now : _ t -> Core_kernel.Time_ns.t
val start : _ t -> Core_kernel.Time_ns.t
val is_empty : _ t -> bool
val length : _ t -> int
val iter : 'a t -> f:('a Alarm.t -> unit) -> unit
val interval_num : _ t -> Core_kernel.Time_ns.t -> Interval_num.t
interval_num t time
returns the number of the interval thattime
is in, where0
is the interval that starts atTime_ns.epoch
.interval_num
raises ifTime_ns.( < ) time Time_ns.epoch
.
val now_interval_num : _ t -> Interval_num.t
now_interval_num t = interval_num t (now t)
.
val interval_num_start : _ t -> Interval_num.t -> Core_kernel.Time_ns.t
interval_num_start t n
is the start of then
'th interval int
, i.e.n * alarm_precision t
after the epoch.interval_start t time
is the start of the half-open interval containingtime
, i.e.:interval_num_start t (interval_num t time)
val interval_start : _ t -> Core_kernel.Time_ns.t -> Core_kernel.Time_ns.t
interval_start
raises in the same cases thatinterval_num
does.
val advance_clock : 'a t -> to_:Core_kernel.Time_ns.t -> handle_fired:('a Alarm.t -> unit) -> unit
advance_clock t ~to_ ~handle_fired
advancest
's clock toto_
. It fires and removes all alarmsa
int
withTime_ns.(<) (Alarm.at t a) (interval_start t to_)
, applyinghandle_fired
to each sucha
.If
to_ <= now t
, thenadvance_clock
does nothing.advance_clock
fails ifto_
is too far in the future to represent.Behavior is unspecified if
handle_fired
accessest
in any way other thanAlarm
functions.
val fire_past_alarms : 'a t -> handle_fired:('a Alarm.t -> unit) -> unit
fire_past_alarms t ~handle_fired
fires and removes all alarmsa
int
withTime_ns.( <= ) (Alarm.at t a) (now t)
, applyinghandle_fired
to each sucha
.fire_past_alarms
visits all alarms in intervalnow_interval_num
, to check theirAlarm.at
.Behavior is unspecified if
handle_fired
accessest
in any way other thanAlarm
functions.
val max_allowed_alarm_time : _ t -> Core_kernel.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.
val min_allowed_alarm_interval_num : _ t -> Interval_num.t
min_allowed_alarm_interval_num t = now_interval_num t
val max_allowed_alarm_interval_num : _ t -> Interval_num.t
max_allowed_alarm_interval_num t = interval_num t (max_allowed_alarm_time t)
val add : 'a t -> at:Core_kernel.Time_ns.t -> 'a -> 'a Alarm.t
add t ~at a
adds a new valuea
tot
and returns an alarm that can later be supplied toremove
the alarm fromt
.add
raises ifinterval_num t at < now_interval_num t || at > max_allowed_alarm_time t
.
val add_at_interval_num : 'a t -> at:Interval_num.t -> 'a -> 'a Alarm.t
add_at_interval_num t ~at a
is equivalent toadd t ~at:(interval_num_start t at) a
.
val mem : 'a t -> 'a Alarm.t -> bool
val remove : 'a t -> 'a Alarm.t -> unit
remove t alarm
removesalarm
fromt
.remove
raises ifnot (mem t alarm)
.
val reschedule : 'a t -> 'a Alarm.t -> at:Core_kernel.Time_ns.t -> unit
reschedule t alarm ~at
mutatesalarm
so that it will fire atat
, i.e. so thatAlarm.at t alarm = at
.reschedule
raises ifnot (mem t alarm)
or ifat
is an invalid time fort
, in the same situations thatadd
raises.
val reschedule_at_interval_num : 'a t -> 'a Alarm.t -> at:Interval_num.t -> unit
reschedule_at_interval_num t alarm ~at
is equivalent to:reschedule t alarm ~at:(interval_num_start t at)
val clear : _ t -> unit
clear t
removes all alarms fromt
.
val min_alarm_interval_num : _ t -> Interval_num.t option
min_alarm_interval_num t
is the minimumAlarm.interval_num
of all alarms int
.
val min_alarm_interval_num_exn : _ t -> Interval_num.t
min_alarm_interval_num_exn t
is likemin_alarm_interval_num
, except it raises ifis_empty t
.
val max_alarm_time_in_min_interval : 'a t -> Core_kernel.Time_ns.t option
max_alarm_time_in_min_interval t
returns the maximumAlarm.at
over all alarms int
whoseAlarm.interval_num
ismin_alarm_interval_num t
. This function is useful for advancing to themin_alarm_interval_num
of a timing wheel and then callingfire_past_alarms
to fire the alarms in that interval. That is useful when simulating time, to ensure that alarms are processed in order.
val max_alarm_time_in_min_interval_exn : 'a t -> Core_kernel.Time_ns.t
max_alarm_time_in_min_interval_exn t
is likemax_alarm_time_in_min_interval
, except that it raises ifis_empty t
.
val next_alarm_fires_at : _ t -> Core_kernel.Time_ns.t option
next_alarm_fires_at t
returns the minimum time to which the clock can be advanced such that an alarm will fire, orNone
ift
has no alarms (or all alarms are in the max interval, and hence cannot fire). Ifnext_alarm_fires_at t = Some next
, then for the minimum alarm timemin
that occurs int
, it is guaranteed that:next - alarm_precision t <= min < next
.
val next_alarm_fires_at_exn : _ t -> Core_kernel.Time_ns.t
next_alarm_fires_at_exn
is likenext_alarm_fires_at
, except that it raises ifis_empty t
.
module Private : sig ... end