<:sexp_of< _ t_now >> displays only now t, not all the alarms.

create ~config ~start creates a new timing wheel with current time start. create raises if start < Time_ns.epoch. For a fixed level_bits, a smaller (i.e. more precise) alarm_precision decreases the representable range of times/keys and increases the constant factor for advance_clock.

Accessors

interval_num t time returns the number of the interval that time is in, where 0 is the interval that starts at Time_ns.epoch. interval_num raises if Time_ns.( < ) time Time_ns.epoch.

now_interval_num t = interval_num t (now t).

interval_num_start t n is the start of the n'th interval in t, i.e. n * alarm_precision t after the epoch.

interval_start t time is the start of the half-open interval containing time, i.e.:

  interval_num_start t (interval_num t time)

interval_start raises in the same cases that interval_num does.

advance_clock t ~to_ ~handle_fired advances t's clock to to_. It fires and removes all alarms a in t with Time_ns.(<) (Alarm.at t a) (interval_start t to_), applying handle_fired to each such a.

If to_ <= now t, then advance_clock does nothing.

advance_clock fails if to_ is too far in the future to represent.

Behavior is unspecified if handle_fired accesses t in any way other than Alarm functions.

Advance to the time to_ or the time of the next alarm, whichever is earlier. This function should be functionally equivalent to advance_clock t ~to_:(Time.min to_ (min_alarm_time_in_min_interval t)), with potentially better performance.

handle_fired may still fire multiple times, if there are multiple alarms scheduled at the same time.

fire_past_alarms t ~handle_fired fires and removes all alarms a in t with Time_ns.( <= ) (Alarm.at t a) (now t), applying handle_fired to each such a.

fire_past_alarms visits all alarms in interval now_interval_num, to check their Alarm.at.

Behavior is unspecified if handle_fired accesses t in any way other than Alarm functions.

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.

min_allowed_alarm_interval_num t = now_interval_num t

max_allowed_alarm_interval_num t = interval_num t (max_allowed_alarm_time t)

add t ~at a adds a new value a to t and returns an alarm that can later be supplied to remove the alarm from t. add raises if interval_num t at < now_interval_num t || at > max_allowed_alarm_time t.

add_at_interval_num t ~at a is equivalent to add t ~at:(interval_num_start t at) a.

remove t alarm removes alarm from t. remove raises if not (mem t alarm).

reschedule t alarm ~at mutates alarm so that it will fire at at, i.e. so that Alarm.at t alarm = at. reschedule raises if not (mem t alarm) or if at is an invalid time for t, in the same situations that add raises.

reschedule_at_interval_num t alarm ~at is equivalent to:

  reschedule t alarm ~at:(interval_num_start t at)

clear t removes all alarms from t.

min_alarm_interval_num t is the minimum Alarm.interval_num of all alarms in t.

min_alarm_interval_num_exn t is like min_alarm_interval_num, except it raises if is_empty t.

max_alarm_time_in_min_interval t returns the maximum Alarm.at over all alarms in t whose Alarm.interval_num is min_alarm_interval_num t. This function is useful for advancing to the min_alarm_interval_num of a timing wheel and then calling fire_past_alarms to fire the alarms in that interval. That is useful when simulating time, to ensure that alarms are processed in order.

min_alarm_time_in_min_interval t returns the minimum Alarm.at over all alarms in t. This function is useful for advancing to the exact time when the next alarm is scheduled to fire.

max_alarm_time_in_min_interval_exn t is like max_alarm_time_in_min_interval, except that it raises if is_empty t.

min_alarm_time_in_min_interval_exn t is like min_alarm_time_in_min_interval, except that it raises if is_empty t.

The name of this function is misleading: it does not take into account events that can fire due to fire_past_alarms.

next_alarm_fires_at t returns the minimum time to which the clock can be advanced such that an alarm will be fired by advance_clock, or None if t has no alarms (or all alarms are in the max interval, and hence cannot fire by advance_clock). If next_alarm_fires_at t = Some next, then for the minimum alarm time min that occurs in t, it is guaranteed that: next - alarm_precision t <= min < next.

next_alarm_fires_at_exn is like next_alarm_fires_at, except that it raises if is_empty t.