Struct L0Manager 

pub struct L0Manager { /* private fields */ }

Implementations

impl L0Manager

pub fn new(start_version: u64, wal: Option<Arc<WriteAheadLog>>) -> Self

pub fn from_snapshot( current: Arc<RwLock<L0Buffer>>, pending_flush: Vec<Arc<RwLock<L0Buffer>>>, ) -> Self

Create a read-only snapshot L0Manager from existing buffers.

Used by the algorithm execution path to provide L0 visibility without owning the actual L0 lifecycle (rotation, flush, WAL).

pub fn get_current(&self) -> Arc<RwLock<L0Buffer>>

Get the current L0 buffer.

pub fn get_all_readable(&self) -> Vec<Arc<RwLock<L0Buffer>>>

Get all L0 buffers that should be visible to reads. This includes the current L0 plus any L0s being flushed.

pub fn get_pending_flush(&self) -> Vec<Arc<RwLock<L0Buffer>>>

Get L0 buffers currently being flushed (for QueryContext).

pub fn rotate( &self, next_version: u64, new_wal: Option<Arc<WriteAheadLog>>, ) -> Arc<RwLock<L0Buffer>>

Rotate L0. Returns the OLD L0 buffer. The new L0 is initialized with next_version and new_wal.

pub fn begin_flush( &self, next_version: u64, new_wal: Option<Arc<WriteAheadLog>>, ) -> Arc<RwLock<L0Buffer>>

Begin flush: rotate L0 and add old L0 to pending flush list. The old L0 remains visible to reads until complete_flush is called. Returns the old L0 buffer to be flushed.

pub fn complete_flush(&self, l0: &Arc<RwLock<L0Buffer>>)

Complete flush: remove the flushed L0 from pending list. Call this only after L1 writes have succeeded.

pub fn snapshot_isolated( &self, next_version: u64, new_wal: Option<Arc<WriteAheadLog>>, ) -> (Arc<RwLock<L0Buffer>>, Vec<Arc<RwLock<L0Buffer>>>)

Captures an isolated snapshot of the current L0 (strategy D).

Freezes the current buffer by rotating it aside — writers re-fetch get_current() at write time, so they move to the fresh buffer and can never mutate the frozen one — and keeps it readable via the pending list. Returns the (frozen_main, pending) pair used to build a QueryContext whose reads are isolated from later writes. Capture is O(1): one empty-buffer allocation and an Arc move, with no deep copy.

The caller must coordinate with the commit path (e.g. hold the writer’s flush_lock) so the rotation does not race an in-flight merge into the current buffer. The frozen generation currently rides the pending-flush list; a dedicated generation list with reader-count GC is the production follow-up (see the proposal’s open questions).

pub fn pin_snapshot(&self) -> SnapshotView

Pins an isolated view of the current L0 tier for a transaction.

O(1): clones the current buffer handle, the pending-flush set, and the generation’s pin token. No freeze happens here — the current buffer keeps taking writes; it is frozen aside lazily, and only if still pinned, when a commit would next mutate it (see Self::freeze_current_for_snapshot and Self::is_current_pinned). Holds the current read lock across the buffer and token clones so both come from the same generation even if a rotate races. Does not require the writer’s flush_lock.

Examples

let snap = writer.l0_manager().pin_snapshot();
// build a QueryContext from `snap.main` + `snap.extra`

pub fn is_current_pinned(&self) -> bool

Returns true if any live SnapshotView pins the current generation.

strong_count > 1 means a snapshot besides the manager holds the token. Call under the writer’s flush_lock at commit so the decision and any resulting freeze are atomic with respect to the merge.

pub fn freeze_current_for_snapshot(&self)

Clones the current (pinned) generation aside so a commit can mutate a fresh buffer without the pinning snapshots observing the write — lazy copy-on-write, performed only when Self::is_current_pinned holds.

The outgoing buffer — which the pinning SnapshotViews hold via main — becomes immutable: a deep copy carrying the same data is installed as the new current, the commit merges into that copy, and the original is never mutated again. L0Buffer::clone drops the WAL handle, so the original’s WAL (already flushed at this commit’s WAL step) is handed to the copy; the frozen original keeps none, as it takes no more writes. The original is not placed on the pending-flush list — it is reclaimed by Arc refcount once the last snapshot drops, so nothing leaks. The new generation starts unpinned (the pin token is reset). Must be called under the writer’s flush_lock, since it swaps the current buffer.

pub fn min_pending_wal_lsn_start( &self, except: &Arc<RwLock<L0Buffer>>, ) -> Option<u64>

Minimum wal_lsn_at_start among pending-flush L0s other than except.

This is the floor below which every WAL entry is durable in L1: a pending flush — one still streaming, or one whose flush FAILED and left the buffer in pending_flush — holds committed WAL entries strictly above its start that are not yet in L1. WAL truncation and the published wal_high_water_mark must not advance past this floor, or that buffer’s committed-but-unflushed data is silently dropped by the next (e.g. shutdown) flush. Using the high watermark (wal_lsn_at_flush) here was the lost-commit bug: it truncated / checkpointed past the pending buffer’s own entries.

except is the buffer the caller is itself flushing — its data IS entering the new snapshot, so it must not constrain the floor. At truncation time it has already been removed via complete_flush, so passing it is a harmless no-op; during the stream phase it is still pending and the exclusion is load-bearing.

Returns None when no other pending flush exists.