pagecache is a lock-free pagecache and log for building high-performance databases.
An atomic pointer that can be safely shared between threads.
Performs exponential backoff in spin loops.
Pads and aligns a value to the length of a cache line.
An epoch-based garbage collector.
The error returned on failed compare-and-set operation.
Top-level configuration for the system.
A guard that keeps the current thread pinned.
A lazily initialized value
A handle to a garbage collector.
A simple Lru cache.
A simple map that can be used to store metadata for the pagecache tenant.
A node in the lock-free
An owned heap-allocated object.
A lock-free pagecache which supports fragmented pages for dramatically improving write throughput.
A pointer to shared lock-free state bound by a pinned epoch's lifetime.
A simple lock-free radix tree.
A Future value which may or may not be filled
The completer side of the Future
Ensures that any operations that are written to disk between the creation of this guard and its destruction will be recovered atomically. When this guard is dropped, it marks in an earlier reservation where the stable tip must be in order to perform recovery. If this is beyond where the system successfully wrote before crashing, then the recovery will stop immediately before any of the atomic batch can be partially recovered.
A pending log reservation which can be aborted or completed.
NB the holder should quickly call
A pointer to an object protected by the epoch GC.
A simple lock-free stack, with the ability to atomically append or entirely swap-out entries.
An iterator over nodes in a lock-free stack.
A set built on top of
A pointer to a location on disk or an off-log blob.
An Error type encapsulating various issues that may come up
in both the expected and unexpected operation of a
The high-level types of stored information about pages and their mutations
The log may be configured to write data in several different ways, depending on the constraints of the system using it.
A metric collector for all pagecache users running in this process.
A user of a
This function is useful for inducing random jitter into our atomic operations, shaking out more possible interleavings quickly. It gets fully elliminated by the compiler in non-test code.
Turns a vector of elements into a lock-free stack of them, and returns the head of the stack.
Pins the current thread.
Returns a reference to a dummy guard that allows unprotected access to
A pointer to an blob blob.
A compare and swap result. If the CAS is successful,
A fast map that is not resistant to collision attacks. Works on one byte at a time.
A fast map that is not resistant to collision attacks. Works on 4 bytes at a time.
A fast map that is not resistant to collision attacks. Works on 8 bytes at a time.
A fast set that is not resistant to collision attacks. Works on one byte at a time.
A fast set that is not resistant to collision attacks. Works on 4 bytes at a time.
A fast set that is not resistant to collision attacks. Works on 8 bytes at a time.
A log file offset.
A logical sequence number.
A page identifier.
The top-level result type for dealing with
An offset for a storage file segment.