Struct RedbBackend 

pub struct RedbBackend { /* private fields */ }

redb-backed durable state. Atomicity comes from redb’s single-writer write transaction: each op’s read-modify-write is applied inside one (ADR 000004). redb is fully synchronous; ADR 000011’s async-aware seam is this KvBackend impl — callers never see the store or the batching behind it.

Writes amortize begin/commit (and fsync when durable) across concurrent callers — the classical group-commit idea (DeWitt et al., SIGMOD’84: share durable I/O across a commit group) — shaped as flat combining (Hendler et al., SPAA’10): a caller queues its op, then competes for the combiner lock; the winner drains up to MAX_BATCH_OPS queued ops and applies them inside ONE write transaction. redb serializes writers globally (begin_write blocks), so per-op transactions would serialize every filter and route on N× the begin/commit cost; combining keeps the single writer but pays that cost once per batch. The batch is self-clocking — no timer, no resident thread: an uncontended caller drains only its own op and runs it inline (zero thread handoff), while contended callers batch what accumulated while the previous combiner held the lock.

Implementations

impl RedbBackend

pub fn open(path: impl AsRef<Path>) -> Result<Self>

Open (or create) the redb database at path.

Trait Implementations

impl KvBackend for RedbBackend

fn get(&self, key: &[u8]) -> Option<Vec<u8>>

fn set(&self, key: &[u8], value: Vec<u8>)

fn delete(&self, key: &[u8])

fn increment(&self, key: &[u8], delta: i64) -> i64

Atomic add-and-get. An unset counter starts at 0; delta is signed.

fn try_acquire( &self, key: &[u8], cost: u64, spec: Bucket, now_ms: u64, ) -> Acquire

Atomic token-bucket acquire against the now_ms request-clock snapshot. The refill + counting stay host-native (ADR 000005) — they never cross the WASM boundary; the filter only decided to consult the limiter.