Index of values

add t ~key value adds a new value to t and returns an element that can later be supplied to remove the element from 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.

advance_clock t ~to_ ~handle_fired advances t's clock to to_.

Accessors

alarm_upper_bound t returns the upper bound on an at that can be supplied to add.

In all Alarm functions, one must supply the timing wheel that the alarm was added to.

blit is like Array.blit, except it uses our own for-loop to avoid caml_modify when possible.

capacity returns the maximum number of tuples that the pool can hold.

create ?level_bits ~dummy () creates a new empty timing wheel, t, with length t = 0 and min_allowed_key t = 0.

create ~start ~alarm_precision ~dummy () creates a new timing wheel with current time start.

create slots ~capacity ~dummy creates an empty pool that can hold up to capacity N-tuples.

create ~len returns an obj-array of length len, all of whose indices have value Obj.repr 0.

create slots ~len init creates an array of len tuples, each initialized to init.

In create_exn bits, it is an error if any of the b_i in bits has b_i <= 0, or if the sum of the b_i in bits is greater than max_num_bits.

default returns the default value of level_bits used by Timing_wheel.create and Timing_wheel.Priority_queue.create.

durations t ~alarm_precision returns the durations of the levels in t, assuming that each interval has duration alarm_precision.

free t pointer frees the tuple pointed to by pointer from t.

get t pointer slot gets slot of the tuple pointed to by pointer in pool t.

get t i slot returns tuple i's slot.

get_tuple t pointer allocates an OCaml tuple isomorphic to the pool t's tuple pointed to by pointer.

get_tuple t i allocates an OCaml tuple isomorphic to the tuple at index i in t.

grow t ~capacity returns a new pool t' with the supplied capacity.

id_of_pointer t pointer is an integer which is unique for the lifetime of a tuple in the pool.

increase_min_allowed_key t ~key ~handle_removed increases the minimum allowed key in t to key, and removes all elements with keys less than key, applying handle_removed to each element that is removed.

interval_start t time returns the time at the start of the half-open interval containing time, i.e.

is_empty t is length t = 0

One can think of a timing wheel as a set of alarms.

is_full t returns true if no more tuples can be allocated in t.

length t returns the number of elements in the timing wheel.

length returns the number of tuples currently in the pool.

max_allowed_key t is the maximum allowed key that can be stored in t.

To avoid issues with arithmetic overflow, the implementation restricts keys to being between 0 and max_representable_key, where:

min_allowed_key t is the minimum key that can be stored in t.

min_elt t returns an element in t that has the minimum key, if t is nonempty.

new<N> t a0 ... a<N-1> returns a new tuple from the pool, with the tuple's slots initialized to a0 ...

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

The null pointer is a distinct pointer that does not correspond to a tuple in the pool.

num_bits t is the sum of the b_i in t.

pointer_is_valid t pointer returns true iff pointer points to a tuple in t, i.e.

pointer_of_id t pointer returns the pointer with this identifier.

remove t elt removes elt from t.

remove t alarm removes alarm from t.

set t pointer slot a sets to a the slot of the tuple pointed to by pointer in pool t.

set t i slot a sets tuple i's slot to a.

sub t ~pos ~len returns a new array containing the len elements of t starting at pos.

truncate t ~len shortens t's length to len.

unsafe_set_assuming_currently_int t i obj sets index i of t to obj, but only works correctly if Obj.is_int (get t i).