Module Tuple_pool
module Tuple_type : sig ... end
Tuple-like types used in
Pool
.
module type S = Tuple_pool__.Tuple_pool_intf.S
This uses a Uniform_array.t
to implement the pool. We expose that Pointer.t
is an int
so that OCaml can avoid the write barrier, due to knowing that Pointer.t
isn't an OCaml pointer.
module Slots : Tuple_type.Slots
module Slot : Tuple_type.Slot
module Pointer : sig ... end
type 'slots t
A pool.
'slots
will look like('a1, ..., 'an) Slots.tn
, and the pool holds tuples of type'a1 * ... * 'an
.
val sexp_of_t : ('slots -> Ppx_sexp_conv_lib.Sexp.t) -> 'slots t -> Ppx_sexp_conv_lib.Sexp.t
val invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
val pointer_is_valid : 'slots t -> 'slots Pointer.t -> bool
pointer_is_valid t pointer
returnstrue
iffpointer
points to a live tuple int
, i.e.pointer
is not null, not free, and is in the range oft
.A pointer might not be in the range of a pool if it comes from another pool for example. In this case unsafe_get/set functions would cause a segfault.
val id_of_pointer : 'slots t -> 'slots Pointer.t -> Pointer.Id.t
id_of_pointer t pointer
returns an id that is unique for the lifetime ofpointer
's tuple. When the tuple is freed, the id is no longer valid, andpointer_of_id_exn
will fail on it.Pointer.null ()
has a distinct id from all non-null pointers.
val pointer_of_id_exn : 'slots t -> Pointer.Id.t -> 'slots Pointer.t
pointer_of_id_exn t id
returns the pointer corresponding toid
. It fails if the tuple corresponding toid
was alreadyfree
d.
val create : ('tuple, 'a) Slots.t -> capacity:int -> dummy:'tuple -> ('tuple, 'a) Slots.t t
create slots ~capacity ~dummy
creates an empty pool that can hold up tocapacity
N-tuples. The slots ofdummy
are stored in free tuples.create
raises ifcapacity < 0 || capacity > max_capacity ~slots_per_tuple
.
val max_capacity : slots_per_tuple:int -> int
max_capacity
returns the maximum capacity allowed when creating a pool.
val capacity : 'a t -> int
capacity
returns the maximum number of tuples that the pool can hold.
val length : 'a t -> int
length
returns the number of tuples currently in the pool.0 <= length t <= capacity t
val grow : ?capacity:int -> 'a t -> 'a t
grow t ~capacity
returns a new poolt'
with the supplied capacity. The new pool is to be used as a replacement fort
. All live tuples int
are now live int'
, and valid pointers to tuples int
are now valid pointers to the identical tuple int'
. It is an error to uset
after callinggrow t
.grow
raises if the supplied capacity isn't larger thancapacity t
.
val is_full : 'a t -> bool
is_full t
returnstrue
if no more tuples can be allocated int
.
val free : 'slots t -> 'slots Pointer.t -> unit
free t pointer
frees the tuple pointed to bypointer
fromt
.
val unsafe_free : 'slots t -> 'slots Pointer.t -> unit
unsafe_free t pointer
frees the tuple pointed to bypointer
without checkingpointer_is_valid
val new1 : 'a0 Slots.t1 t -> 'a0 -> 'a0 Slots.t1 Pointer.t
new<N> t a0 ... a<N-1>
returns a new tuple from the pool, with the tuple's slots initialized toa0
...a<N-1>
.new
raises ifis_full t
.
val new2 : ('a0, 'a1) Slots.t2 t -> 'a0 -> 'a1 -> ('a0, 'a1) Slots.t2 Pointer.t
val new3 : ('a0, 'a1, 'a2) Slots.t3 t -> 'a0 -> 'a1 -> 'a2 -> ('a0, 'a1, 'a2) Slots.t3 Pointer.t
val new4 : ('a0, 'a1, 'a2, 'a3) Slots.t4 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> ('a0, 'a1, 'a2, 'a3) Slots.t4 Pointer.t
val new5 : ('a0, 'a1, 'a2, 'a3, 'a4) Slots.t5 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> ('a0, 'a1, 'a2, 'a3, 'a4) Slots.t5 Pointer.t
val new6 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) Slots.t6 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) Slots.t6 Pointer.t
val new7 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) Slots.t7 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) Slots.t7 Pointer.t
val new8 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) Slots.t8 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) Slots.t8 Pointer.t
val new9 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) Slots.t9 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) Slots.t9 Pointer.t
val new10 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9) Slots.t10 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9) Slots.t10 Pointer.t
val new11 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10) Slots.t11 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10) Slots.t11 Pointer.t
val new12 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11) Slots.t12 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11) Slots.t12 Pointer.t
val new13 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12) Slots.t13 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12) Slots.t13 Pointer.t
val new14 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12, 'a13) Slots.t14 t -> 'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 -> 'a13 -> ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12, 'a13) Slots.t14 Pointer.t
val get_tuple : ('tuple, 'a) Slots.t t -> ('tuple, 'a) Slots.t Pointer.t -> 'tuple
get_tuple t pointer
allocates an OCaml tuple isomorphic to the poolt
's tuple pointed to bypointer
. The tuple gets copied, but its slots do not.
val get : ('a, 'variant) Slots.t t -> ('a, 'variant) Slots.t Pointer.t -> ('variant, 'slot) Slot.t -> 'slot
get t pointer slot
getsslot
of the tuple pointed to bypointer
in poolt
.set t pointer slot a
sets toa
theslot
of the tuple pointed to bypointer
in poolt
.In
get
andset
, it is an error to refer to a pointer that has beenfree
d. It is also an error to use a pointer with any pool other than the one the pointer wasnew
'd from orgrow
n to. These errors will lead to undefined behavior, but will not segfault.unsafe_get
is comparable in speed toget
for immediate values, and 5%-10% faster for pointers.unsafe_get
andunsafe_set
skip bounds checking, and can thus segfault.
val unsafe_get : ('a, 'variant) Slots.t t -> ('a, 'variant) Slots.t Pointer.t -> ('variant, 'slot) Slot.t -> 'slot
val set : ('a, 'variant) Slots.t t -> ('a, 'variant) Slots.t Pointer.t -> ('variant, 'slot) Slot.t -> 'slot -> unit
val unsafe_set : ('a, 'variant) Slots.t t -> ('a, 'variant) Slots.t Pointer.t -> ('variant, 'slot) Slot.t -> 'slot -> unit
module Unsafe : sig ... end
An
Unsafe
pool is like an ordinary pool, except that thecreate
function does not require an initial element. The pool stores a dummy value for each slot. Such a pool is only safe if one never accesses a slot from afree
d tuple.
module Debug : functor (Tuple_pool : S) -> sig ... end
Debug
builds a pool in which every function can runinvariant
on its pool argument(s) and/or print a debug message to stderr, as determined by!check_invariant
and!show_messages
, which are initially bothtrue
.
module Error_check : functor (Tuple_pool : S) -> S
Error_check
builds a pool that has additional error checking for pointers, in particular to detect using afree
d pointer or multiplyfree
ing a pointer.