Struct StackAlloc 

pub struct StackAlloc<B: FixedRange> { /* private fields */ }

LIFO-discipline allocator over a FixedRange backing.

Maintains a frame stack so nested alloc/free with arbitrary depth works correctly. Each allocate pushes the new frame’s offset; deallocate validates the supplied pointer matches the top of the stack and pops.

Implementations

impl<B: FixedRange> StackAlloc<B>

pub fn new(backing: B) -> Result<Self, AllocError>

Construct a LIFO allocator over backing’s entire range.

The frame stack starts at capacity 0 and grows on demand via the global allocator. For workloads with a known maximum nesting depth, prefer Self::with_max_depth to pre-reserve the frame stack and avoid heap reallocations on the alloc hot path.

pub fn with_max_depth(backing: B, max_depth: usize) -> Result<Self, AllocError>

Construct with a hint for the maximum frame depth. The frame stack is pre-allocated with max_depth capacity, so the alloc hot path does not trigger a Vec grow / reallocation for the first max_depth nested allocations.

If max_depth is exceeded at runtime the Vec will grow normally — the constructor’s value is a hint, not a hard cap. Pass 0 for the same behavior as Self::new.

pub fn allocated(&self) -> usize

Bytes currently in use.

pub fn remaining(&self) -> usize

Bytes remaining.

pub fn backing(&self) -> &B

Borrow the backing.

Trait Implementations

impl<B: FixedRange> Allocator for StackAlloc<B>

fn allocate(&self, layout: NonZeroLayout) -> Result<NonNull<[u8]>, AllocError>

Allocate a block satisfying layout. The returned slice’s length is at least layout.size() but may be larger.

fn capacity_bytes(&self) -> Option<usize>

Total bytes this allocator can issue, if bounded. None for unbounded allocators like System. Used by Watermark to compute thresholds.

fn allocate_zeroed( &self, layout: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Allocate a zero-initialized block.

unsafe fn grow( &self, ptr: NonNull<u8>, old: NonZeroLayout, new: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Grow an allocation in place if possible, otherwise allocate-copy-free.

unsafe fn shrink( &self, ptr: NonNull<u8>, old: NonZeroLayout, new: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Shrink an allocation in place if possible, otherwise allocate-copy-free.

fn reset(&mut self) -> Result<(), AllocError>

Reclaim everything previously allocated. Default impl returns AllocError — only arena-style allocators implement a meaningful reset.

unsafe fn usable_size( &self, _ptr: NonNull<u8>, _layout: NonZeroLayout, ) -> Option<usize>

Usable size of an existing allocation, if the allocator can report it. Defaults to None — implementors that track usable size override.

fn corruption_events(&self) -> u64

Detected freelist / metadata corruption events observed by this allocator since construction.

impl<B: FixedRange> Deallocator for StackAlloc<B>

unsafe fn deallocate(&self, ptr: NonNull<u8>, _layout: NonZeroLayout)

Release a previously allocated block.

impl<B: FixedRange> FixedRange for StackAlloc<B>

fn base(&self) -> NonNull<u8>

First byte of the owned address range.

fn size(&self) -> usize

Length in bytes of the owned address range.

fn commit(&self, offset: usize, len: usize) -> Result<(), AllocError>

Ensure the bytes [offset, offset + len) (relative to base) are backed by committed, writable memory before a consumer writes through them.

fn contains(&self, ptr: NonNull<u8>) -> bool

Whether ptr lies within [base, base + size).