Template Class BucketPoolAllocator¶

Defined in File pool_allocator.h

Class Documentation¶

template<size_t B, size_t C, typename L = SpinLock, bool check_allocations = false> class BucketPoolAllocator¶

Variable-size pool allocator with fixed-size buckets and embedded freelist.

BucketPoolAllocator is a variant of PoolAllocator for raw memory allocations (void*) up to a maximum bucket size. Instead of typed objects, it allocates fixed-size buckets that can hold variable-sized data. This is useful for small message queues, string buffers, or other variable-sized temporary allocations where the maximum size is known.

Like PoolAllocator, this uses an embedded freelist for O(1) allocation and deallocation, with the same LIFO reuse pattern. The constraint B >= sizeof(void*) exists for the same reason: free buckets must be large enough to store a pointer to the next free bucket.

The optional check_allocations template parameter enables allocation tracking using an atomic counter. When enabled, get_allocation_size() returns the number of currently allocated buckets, useful for debugging or telemetry.

Example - Small message queue:

// Pool for messages up to 256 bytes, max 100 messages
BucketPoolAllocator<256, 100> message_pool;

void send_message(const void* data, size_t size) {
    if (size > 256) {
        // Message too large, handle error
        return;
    }
    void* bucket = message_pool.alloc();
    std::memcpy(bucket, data, size);
    message_queue.push({bucket, size});
}

void process_messages() {
    while (!message_queue.empty()) {
        auto [bucket, size] = message_queue.pop();
        handle_message(bucket, size);
        message_pool.free(bucket);
    }
}