Struct ArenaAllocator 

pub struct ArenaAllocator<A: Allocator> { /* private fields */ }

A block-based allocator that frees all memory at once.

ArenaAllocator<A> is generic over its backing allocator A which is called for each individual block allocation and for every block deallocation during reset.

The internal state uses Cell to allow shared (&self) allocation, which is necessary so that multiple collections can borrow the same arena simultaneously.

Dropping

Dropping an ArenaAllocator automatically calls reset, returning all memory to the backing allocator.

Implementations

impl<A: Allocator> ArenaAllocator<A>

pub fn new(backing: A) -> Self

Creates a new, empty arena backed by backing.

No memory is allocated from backing until the first call to alloc.

Examples found in repository

examples/arena_vec.rs (line 7)

fn main() {
    let sys = SystemAllocator;
    let arena = ArenaAllocator::new(&sys);

    let mut numbers = ExVec::new(&arena);

    for i in 1..=100 {
        numbers.push(i);
    }

    println!("Sum: {}", numbers.iter().sum::<i32>());
    
    arena.reset();
    println!("Arena memory reclaimed. Allocations count was: {}", arena.alloc_count());
}

examples/full.rs (line 25)

fn main() {
    let sys = CountingAllocator::new(SystemAllocator);
    
    println!("=== ExBox & SystemAllocator ===");
    {
        let b = ExBox::new(42, &sys).expect("Failed to alloc Box");
        println!("Box value: {}", *b);
    }
    
    let stats = sys.stats();
    println!("Allocated: {} bytes", stats.bytes_allocated);
    println!("Deallocated: {} bytes", stats.bytes_freed);
    println!("Live bytes: {}\n", stats.bytes_live);

    println!("=== ExVec & Arena (Linear Allocation) ===");
    {
        let arena = ArenaAllocator::new(&sys);
        
        let mut v = ExVec::new(&arena);
        for i in 0..5 {
            v.push(i * 10);
        }
        println!("Vec: {:?}", v.as_slice());
        
        arena.reset();
        println!("Arena reset performed");
    }

    println!("\n=== ExString & Pool (Fixed Size Blocks) ===");
    {
        let pool = PoolAllocator::typed::<[u8; 64]>(&sys, 10)
            .expect("Failed to create Pool");
        
        let mut s = ExString::new(&pool);
        s.push_str("Hello from ZigZag!");
        
        println!("String in Pool: {}", s.as_str());
        println!("Pool free slots: {}", pool.free_count());
    }

    println!("\n=== Final Global Stats ===");
    let final_stats = sys.stats();
    println!("Total count of alloc() calls: {}", final_stats.allocs);
    println!("Total count of dealloc() calls: {}", final_stats.deallocs);
    println!("Total bytes allocated: {}", final_stats.bytes_allocated);
    println!("Total bytes freed: {}", final_stats.bytes_freed);
    println!("Current leak/live size: {} bytes", final_stats.bytes_live);
}

pub fn alloc_count(&self) -> usize

Returns the number of live allocations currently managed by this arena.

The counter is reset to zero by reset or reset_zeroed.

Examples found in repository

examples/arena_vec.rs (line 18)

fn main() {
    let sys = SystemAllocator;
    let arena = ArenaAllocator::new(&sys);

    let mut numbers = ExVec::new(&arena);

    for i in 1..=100 {
        numbers.push(i);
    }

    println!("Sum: {}", numbers.iter().sum::<i32>());
    
    arena.reset();
    println!("Arena memory reclaimed. Allocations count was: {}", arena.alloc_count());
}

pub fn reset(&self)

Releases all memory blocks managed by this arena back to the backing allocator.

After this call, all pointers previously returned by alloc are invalid.

Safety

The caller must ensure that no pointers previously obtained from this arena are used after reset returns (use-after-free).

Examples found in repository

examples/arena_vec.rs (line 17)

fn main() {
    let sys = SystemAllocator;
    let arena = ArenaAllocator::new(&sys);

    let mut numbers = ExVec::new(&arena);

    for i in 1..=100 {
        numbers.push(i);
    }

    println!("Sum: {}", numbers.iter().sum::<i32>());
    
    arena.reset();
    println!("Arena memory reclaimed. Allocations count was: {}", arena.alloc_count());
}

examples/full.rs (line 33)

fn main() {
    let sys = CountingAllocator::new(SystemAllocator);
    
    println!("=== ExBox & SystemAllocator ===");
    {
        let b = ExBox::new(42, &sys).expect("Failed to alloc Box");
        println!("Box value: {}", *b);
    }
    
    let stats = sys.stats();
    println!("Allocated: {} bytes", stats.bytes_allocated);
    println!("Deallocated: {} bytes", stats.bytes_freed);
    println!("Live bytes: {}\n", stats.bytes_live);

    println!("=== ExVec & Arena (Linear Allocation) ===");
    {
        let arena = ArenaAllocator::new(&sys);
        
        let mut v = ExVec::new(&arena);
        for i in 0..5 {
            v.push(i * 10);
        }
        println!("Vec: {:?}", v.as_slice());
        
        arena.reset();
        println!("Arena reset performed");
    }

    println!("\n=== ExString & Pool (Fixed Size Blocks) ===");
    {
        let pool = PoolAllocator::typed::<[u8; 64]>(&sys, 10)
            .expect("Failed to create Pool");
        
        let mut s = ExString::new(&pool);
        s.push_str("Hello from ZigZag!");
        
        println!("String in Pool: {}", s.as_str());
        println!("Pool free slots: {}", pool.free_count());
    }

    println!("\n=== Final Global Stats ===");
    let final_stats = sys.stats();
    println!("Total count of alloc() calls: {}", final_stats.allocs);
    println!("Total count of dealloc() calls: {}", final_stats.deallocs);
    println!("Total bytes allocated: {}", final_stats.bytes_allocated);
    println!("Total bytes freed: {}", final_stats.bytes_freed);
    println!("Current leak/live size: {} bytes", final_stats.bytes_live);
}

pub fn reset_zeroed(&self)

Zeroes the user-data portion of every block before releasing them.

Equivalent to reset but erases sensitive data first using SIMD-accelerated zero-fill.

Safety

Same as reset: all previously returned pointers are invalidated.

Trait Implementations

impl<A: Allocator> Allocator for ArenaAllocator<A>

unsafe fn alloc(&self, layout: Layout) -> Option<NonNull<u8>>

Allocates a new block, prepends a [Header], and returns a pointer to the user-data region.

Internally calls the backing allocator for a single block large enough to hold both the Header and the user data (with proper alignment padding in between), then links the new block at the head of the internal list.

Safety

• layout.size() must be greater than zero.
• The returned pointer is valid until the next call to reset or until the arena is dropped.

unsafe fn dealloc(&self, _: NonNull<u8>, _: Layout)

No-op. Arena memory cannot be freed individually.

To release all memory, call reset or drop the arena.

Safety

Even though this method is a no-op, callers must not use ptr after calling dealloc — the pointer will become dangling once reset is eventually called.

impl<A: Allocator> ArenaExt for ArenaAllocator<A>

unsafe fn alloc_zeroed(&self, layout: Layout) -> Option<NonNull<u8>>

Allocates a block and zero-fills the user-data region with SIMD.

Delegates to alloc and then applies a SIMD zero-fill, which is faster than a scalar loop for large allocations.

Safety

• layout.size() must be greater than zero.
• The returned pointer becomes invalid after reset or when the arena is dropped.

impl<A: Allocator> Drop for ArenaAllocator<A>

fn drop(&mut self)

Releases all managed blocks by calling reset.