val empty_cache : unit -> cache
Construct a new empty cache of index instances.
val v : ?flush_callback:(unit -> unit) -> ?cache:cache -> ?fresh:bool -> ?readonly:bool -> ?throttle:[ `Overcommit_memory | `Block_writes ] -> log_size:int -> string -> t
The constructor for indexes.
val clear : t -> unit
clear t clears
t so that there are no more bindings in it.
replace t k v binds
t, replacing any existing binding of
overcommit is true, the operation does not triger a merge, even if the caches are full. By default
overcommit is false.
filter t p removes all the bindings (k, v) that do not satisfy
p. This operation is costly and blocking.
Iterates over the index bindings. Limitations:
- Order is not specified.
- In case of recent replacements of existing values (since the last merge), this will hit both the new and old bindings.
- May not observe recent concurrent updates to the index by other processes.
val flush : ?no_callback:unit -> ?with_fsync:bool -> t -> unit
Flushes all internal buffers of the
~no_callback:()disables calling the
true, this also flushes the OS caches for each
val close : ?immediately:unit -> t -> unit
Closes all resources used by
t, flushing any internal buffers in the instance.
immediately is passed, this operation will abort any ongoing background processes. This guarantees not to corrupt the store, but may require additional work to be done on the next startup.
val sync : t -> unit
sync t syncs a read-only index with the files on disk. Raises
RW_not_allowed if called by a read-write index.
val is_merging : t -> bool
is_merging t returns true if
t is running a merge. Raises
RO_not_allowed if called by a read-only index.
val merge : t -> unit
merge t forces a merge for
If there is no merge running, this operation is non-blocking, i.e. it returns immediately, with the merge running concurrently.
If a merge is running already, this operation blocks until the previous merge is complete. It then launches a merge (which runs concurrently) and returns.
val try_merge : t -> unit
try_merge is like
merge but is a no-op if the number of entries in the write-ahead log is smaller than
module Checks : sig ... end
fsck-like utility for checking the integrity of Index stores built using this module.
Some operations that trigger a merge can have hooks inserted at the following stages:
`Before: immediately before merging (while holding the merge lock);
`After_clear: immediately after clearing the log, at the end of a merge;
`After_first_entry: immediately after adding the first entry in the merge file, if the data file contains at least one entry;
`After: immediately after merging (while holding the merge lock).
val replace' : ?hook:[ `Merge of merge_stages ] Hook.t -> ?overcommit:bool -> t -> key -> value -> merge_result async option
replace' t k v is like
replacetkv but returns a promise of a merge result if the
replace call triggered one.
`Abort_signalled: after the cancellation signal has been sent to any concurrent merge operations, but before blocking on those cancellations having completed.
try_merge_aux t tries to merge
force is false (the default), a merge is performed only if there is more entries in the write-ahead log than the configured limits. If
force is set, the merge is performed no matter what.
Wait for an asynchronous computation to finish.
Time replace operations. The reported time is an average on an number of consecutive operations, which can be specified by
sampling_interval is not set, no operation is timed.
val sync' : ?hook: [ `Before_offset_read | `After_offset_read | `Reload_log | `Reload_log_async ] Hook.t -> t -> unit
`Before_offset_read: before reading the generation number and the offset.
`After_offset_read: after reading the generation number and offset.