Class StackAllocator¶

Defined in File stack_allocator.h

Class Documentation¶

class StackAllocator¶

Bump/linear allocator providing O(1) allocation via pointer increment.

StackAllocator maintains a contiguous buffer and a ‘top’ marker. Allocation simply increments the top pointer (bounds-checked), making it extremely fast compared to general-purpose allocators. This is ideal for temporary allocations with similar lifetimes, such as per-frame data in game engines.

The key feature is marker-based bulk deallocation: capture a marker with get_marker(), perform any number of allocations, then free_to_marker() to instantly free everything allocated since that marker by resetting the top pointer.

Individual free() is supported but only efficient for LIFO (stack) order. The allocator tracks allocations in an internal map, so marker-based freeing is preferred for performance.

Thread Safety: NOT thread-safe. Designed for single-threaded contexts where one thread owns the allocator for its temporary allocations.

Example - Per-frame temporary allocations:

StackAllocator frame_alloc(1024 * 1024);  // 1MB buffer

void process_frame() {
    auto marker = frame_alloc.get_marker();

    // Allocate temporary data for this frame
    auto* entities = frame_alloc.alloc<EntityList>(100);
    auto* transform_buffer = frame_alloc.alloc<Transform>(entities->size());

    // ... use data throughout frame processing ...

    // Free all frame allocations instantly
    frame_alloc.free_to_marker(marker);
}

Important Notes:

Markers become invalid after resize() or clear()
Default size is 1KB (see implementation) - size appropriately for your use case
Allocation throws std::bad_alloc when buffer is full
Alignment: No alignment guarantees beyond byte alignment. Types requiring stricter alignment (SSE vectors, cache-line alignment) may exhibit undefined behavior. For aligned types, use aligned_alloc or posix_memalign instead.
Complements mimalloc (the global allocator) for specific high-performance patterns