Struct BlockAllocator 

pub struct BlockAllocator { /* private fields */ }

LIFO free-list block allocator. O(1) allocate / free, no fragmentation (all blocks are uniform size).

capacity is the total physical block count baked into the pool at load time. The allocator is independent per-model (block index space is not portable across models).

Implementations

impl BlockAllocator

pub fn new(num_blocks: u32) -> Self

Create a fresh allocator. All num_blocks blocks start free. Free-list is built so allocate() returns block 0 first, then 1, etc. — predictable for tests and ensures the lower physical blocks see the most reuse (better cache locality on M1’s SLC).

pub fn allocate(&mut self) -> Result<u32>

Allocate a single physical block. Returns Err when the pool is exhausted — caller is expected to refuse the request and queue it (or evict another seq, when that’s wired up).

pub fn allocate_n(&mut self, n: usize) -> Result<Vec<u32>>

Bulk allocate. Atomic: either all n succeed or none are taken.

pub fn free(&mut self, blocks: &[u32])

Return blocks to the free list. Caller is responsible for ensuring no live sequence still references them; freeing a block while it’s still in a PagedSeqState::blocks will silently corrupt the next allocation that gets it.

pub fn free_count(&self) -> usize

pub fn capacity(&self) -> u32

pub fn peak_in_use(&self) -> usize