Struct CountingAllocator 

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

An Allocator wrapper that records allocation and deallocation statistics.

Wrap any existing allocator with CountingAllocator::new(inner) to transparently instrument it. Statistics can be queried at any time via stats and reset via reset_stats.

Thread Safety

CountingAllocator uses Cell internally, which is not Sync. It is suitable for single-threaded use only. For multi-threaded scenarios, wrap an atomic-based allocator instead.

Implementations

impl<A: Allocator> CountingAllocator<A>

pub fn new(inner: A) -> Self

Creates a new CountingAllocator wrapping inner.

All counters start at zero.

Examples found in repository

examples/full.rs (line 10)

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 stats(&self) -> AllocStats

Returns a snapshot of all statistics.

Counters are cumulative since the last call to reset_stats.

Example

let counting = CountingAllocator::new(SystemAllocator);
let _ = unsafe { counting.alloc(Layout::new::<u64>()) };
let stats = counting.stats();
assert_eq!(stats.allocs, 1);
assert_eq!(stats.bytes_allocated, 8);

Examples found in repository

examples/full.rs (line 18)

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_stats(&self)

Resets all counters to zero.

Does not affect the underlying allocator or any live allocations.

Trait Implementations

impl<A: Allocator> Allocator for CountingAllocator<A>

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

Forwards the allocation to the inner allocator and records statistics.

Only successful allocations are counted; if the inner allocator returns None, the counters are not updated.

Safety

Inherits all safety requirements from A::alloc.

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

Forwards the deallocation to the inner allocator and records statistics.

Safety

Inherits all safety requirements from A::dealloc. In particular, ptr must have been obtained from this allocator (and therefore from its inner allocator).