Struct KeyArena 

pub struct KeyArena { /* private fields */ }

Thread-local arena allocator for key buffers

Provides O(1) bump-pointer allocation for temporary key data. Much faster than malloc for high-frequency allocations.

Performance

• Bump allocation: ~3ns vs ~50ns for malloc
• No fragmentation within transaction scope
• Automatic reset between transactions

Usage Pattern

KeyArena::with(|arena| {
    let key1 = arena.alloc_key(b"table/123/column");
    let key2 = arena.alloc_key(b"table/456/other");
    // Use keys...
    // Arena is automatically reused for next call
});

Implementations

impl KeyArena

pub fn new() -> Self

Create a new arena with default chunk size

pub fn with_chunk_size(chunk_size: usize) -> Self

Create arena with custom chunk size

pub fn with<F, R>(f: F) -> R

where F: FnOnce(&KeyArena) -> R,

Access the thread-local arena

The callback receives a reference to the thread-local arena. This is the recommended API for arena access.

pub fn alloc_key<'a>(&'a self, data: &[u8]) -> ArenaKey<'a>

Allocate a key in the arena (bump allocation)

Returns an ArenaKey that references data in the arena. The returned key is valid until the arena is reset.

Performance

• Fast path (fits in current chunk): ~3ns
• Slow path (new chunk needed): ~50ns + allocation

pub fn reset(&self)

Reset the arena for reuse

This is O(1) - just resets the allocation pointers. Existing chunks are kept for reuse.

pub fn bytes_used(&self) -> usize

Get total bytes allocated since last reset

pub fn chunk_count(&self) -> usize

Get the number of chunks allocated

Trait Implementations

impl Default for KeyArena

fn default() -> Self

Returns the “default value” for a type.