Memory Pools & Arenas

By the end of this lesson you'll understand why per-object new/delete is slow in a hot loop, and you'll be able to build a fixed-block pool allocator and a bump-pointer arena by hand, recycle objects with an object pool, and reach for std::pmr when you want the speed without writing the allocator yourself.

1. The Fixed-Block Pool Allocator

A pool carves one big block into equal-sized slots and hands them out one at a time. The clever bit is the free list: while a slot is unused, you reuse its own bytes to store a pointer to the next free slot. Allocation pops the head of that list and deallocation pushes a slot back onto it — both are O(1) with zero extra memory. Read this worked example carefully; every non-obvious line is commented with what it does.

#include <iostream>
using namespace std;

// A POOL hands out fixed-size SLOTS from one big block.
// Trick: while a slot is free we reuse its bytes to store a
// pointer to the NEXT free slot -> a "free list" with zero extra memory.
class BytePool {
    static const int SLOT = 32;   // bytes per slot
    static const int COUNT = 4;   // how many slots
    char buffer[SLOT * COUNT];    // one contiguous block
    void* freeList = nullptr;     // head of the free list

public:
    BytePool() {
  
...

A raw byte pool is fine for learning, but in real code you want a typed object pool that constructs a real object in the slot. That needs placement new — new (ptr) T(args) runs a constructor on memory you already own, without allocating anything. Because placement new never pairs with delete, you must call the destructor yourself with ptr->~T() before recycling the slot.

#include <iostream>
#include <new>     // placement new
using namespace std;

struct Bullet {
    int id; float x;
    Bullet(int i, float px) : id(i), x(px) {
        cout << "  Bullet " << id << " spawned at x=" << x << "\n";
    }
    ~Bullet() { cout << "  Bullet " << id << " destroyed\n"; }
};

template <typename T, int N>
class ObjectPool {
    // A slot is raw, correctly-sized, correctly-aligned bytes for ONE T,
    // OR a pointer to the next free slot when the slot is empty.
    union S
...

2. The Arena (Bump) Allocator

An arena (also called a bump allocator) is even simpler than a pool. It keeps one cursor — an offset — and every allocation just hands back the current position then moves the cursor forward. You never free individual objects; instead you reset() the whole arena, which rewinds the cursor to 0 and reclaims everything at once in O(1). This is ideal for data with a clear phase: per-frame game state, per-request server scratch memory, or a compiler's AST nodes. Now you finish one.

The program below is almost complete — fill in the two blanks marked ___ using the // 👉 hints, then run it and check it against the expected output.

#include <iostream>
using namespace std;

// 🎯 YOUR TURN — finish this ARENA (bump) allocator.
// An arena hands out memory by moving "offset" forward. Freeing
// everything is just resetting offset back to 0 -> O(1).
class Arena {
    char buffer[256];
    size_t offset = 0;
public:
    void* allocate(size_t bytes) {
        if (offset + bytes > sizeof(buffer)) return nullptr;
        void* ptr = buffer + offset;

        // 1) Move the cursor forward by 'bytes' so the next
        //    alloc
...

3. std::pmr — Standard Allocators Without the Boilerplate

Hand-writing allocators is great for understanding, but C++17 gives you a ready-made framework: std::pmr (polymorphic memory resources). A std::pmr::memory_resource is an object that knows how to hand out memory, and pmr containers like pmr::vector take their memory from it. Two come built in: monotonic_buffer_resource is an arena (bump, reset on destruction), and unsynchronized_pool_resource is a pool. You get custom-allocator speed without writing the allocator — and you can swap strategies without changing the container's type.

#include <iostream>
#include <vector>
#include <memory_resource>   // std::pmr (C++17)
using namespace std;

int main() {
    // Give a fixed stack buffer to a monotonic_buffer_resource:
    // it's an ARENA -> bump allocate, never reuses freed memory,
    // releases it all when the resource dies. No heap calls at all.
    char buffer[1024];
    pmr::monotonic_buffer_resource arena{buffer, sizeof(buffer)};

    // A pmr::vector takes its memory FROM that resource.
    pmr::vector<int> v{&arena}
...

void* mem = pool.raw_slot();      // raw, owned bytes
T* obj = new (mem) T(args);        // placement new: construct in place
// ... use obj ...
obj->~T();                         // run the destructor BY HAND
pool.recycle(mem);                 // now the slot is safe to reuse

#include <iostream>
#include <new>
using namespace std;

struct Token { int kind; };

int main() {
    // 🎯 MINI-CHALLENGE: a tiny fixed-block Token pool
    // 1. Make a union Slot holding either a Token or a Slot* next.
    // 2. Make an array of, say, 4 Slots and link them into a free list.
    // 3. Write create(): pop the free list, placement-new a Token,
    //    return the pointer (or nullptr if the pool is empty).
    // 4. Write destroy(Token*): call ~Token(), push the slot back.
    
...