Template Class BufferedAllocator¶

Defined in File stack_allocator.h

Class Documentation¶

template<unsigned int N> class BufferedAllocator¶

Multi-buffered allocator wrapping N StackAllocators for round-robin frame buffering.

BufferedAllocator manages N independent StackAllocators and rotates through them using swap_buffers(). This enables safe multi-frame data persistence, essential for scenarios where frame N data must remain valid while frame N+1 is prepared, such as GPU resource updates that execute asynchronously.

Each swap_buffers() call advances to the next allocator (wrapping at N) and clears it, ensuring old data from N frames ago is freed. With double buffering (N=2), frame N writes to buffer 0 while GPU reads frame N-1 from buffer 1. With triple buffering (N=3), an additional frame of overlap is provided for even more CPU/GPU parallelism.

All allocation and deallocation operations (alloc(), free()) operate on the current buffer selected by the internal stack_index. Use get_allocator(index) to access specific buffers if needed.

Example - Double-buffered GPU resource updates:

BufferedAllocator<2> gpu_staging(4 * 1024 * 1024);  // 4MB per buffer

void render_frame() {
    // Allocate staging data in current buffer
    auto* vertices = gpu_staging.alloc<Vertex>(vertex_count);
    auto* uniforms = gpu_staging.alloc<UniformData>();

    // Fill data and upload to GPU
    fill_vertex_buffer(vertices, vertex_count);
    gpu_upload(vertices, sizeof(Vertex) * vertex_count);

    // Submit GPU commands referencing this buffer's data
    submit_render_commands();

    // Swap to next buffer (clears it, but previous buffer remains valid
    // for GPU to read while we prepare the next frame)
    gpu_staging.swap_buffers();
}

Example - Triple buffering for maximum overlap:

BufferedAllocator<3> triple_buffer(2 * 1024 * 1024);
// Frame N-2 data being read by GPU
// Frame N-1 data in flight
// Frame N being written by CPU