Optimizing C++ Memory Management with a Custom Memory Pool

In performance-critical applications like game engines and real-time systems, frequent memory allocations can become a bottleneck, leading to increased latency and memory fragmentation. To tackle this, I developed a custom memory pool allocator that preallocates memory, minimizes allocation overhead, and optimizes memory reuse.

In this post, I’ll walk you through the design, implementation, and performance benchmarks of this custom memory pool allocator.

Key Features of the Memory Pool

The memory pool is designed with a few key objectives in mind:

Efficient Memory Allocation: By managing memory in preallocated chunks, the pool reduces the need for frequent allocations and minimizes memory fragmentation.
Exponential Growth: The pool can grow dynamically, either in fixed blocks or exponentially, depending on configuration. This helps avoid frequent resizing, especially in applications where objects are created in batches.
Reusable Memory: The memory pool uses a linked-list structure to recycle memory. When an object is deallocated, its memory block is returned to the pool for future use, ensuring efficient reallocation.

Chapter 1: Chunk and Memory Storage

At the core of this memory pool is the chunk, a small memory block that can either store an object or point to the next available space in the pool. This dual functionality allows us to optimize memory usage by using each chunk as either storage or a free list entry.

Chunk Design

The chunk structure is defined as a union, which provides the flexibility needed for managing memory efficiently. Here’s how it looks:

template <typename T>
union Chunk {
    /** Storage for a single object */
    typename std::aligned_storage<sizeof(T), alignof(T)>::type element;

    /** Pointer to the next free space in the pool */
    Chunk* next;
};

Using std::aligned_storage ensures that element is aligned and sized properly for any type T, allowing objects to be constructed in-place. When the chunk is not in use, next points to the next available chunk in the pool, creating a linked list of free memory blocks.

Free List Management

The free list keeps track of available chunks. When a chunk is released, it is returned to the free list, enabling rapid reallocation. This approach avoids the overhead of constantly calling new and delete, making the memory pool more efficient than standard allocation methods.

Chapter 2: Reserve and Allocation

Reserve Method: Expanding the Pool

The reserve method ensures that enough space is preallocated for additional objects, dynamically expanding as needed. Depending on the configuration, the pool can grow in fixed-size chunks or exponentially.

void reserve(size_t reserveSize) {
    if (reserveSize < size) return;

    while (reserveSize >= size) {
        const size_t blockSize = N >= 2 ? N : size == 0 ? 1 : size + 1;
        auto newBlock = new Chunk<T>[blockSize];
        chunkList.push_back(newBlock);
        size += blockSize;
    }
}

Initial Check: If the requested size is less than the current pool size, no expansion is needed.
Dynamic Block Sizing: When N == 1, the pool grows exponentially, doubling the block size each time. This strategy reduces the need for frequent expansions.
Memory Tracking: Each new block of Chunk<T> is added to chunkList for easier deallocation later.

Allocation Method: Constructing Objects in the Pool

The allocate function constructs objects within the memory pool. It first checks for available memory in the free list, and if no chunks are available, it expands the pool.

template <typename... Args>
T* allocate(Args&&... args) {
    if (freeList) {
        auto chunk = freeList;
        freeList = chunk->next;
        ::new(&(chunk->element)) T(std::forward<Args>(args)...);
        return reinterpret_cast<T*>(chunk);
    }

    const size_t index = nbElements++;
    if (index >= size) reserve(index);

    Chunk<T>* chunk = &chunkList[listPos][vectorPos];
    ::new(&(chunk->element)) T(std::forward<Args>(args)...);
    return reinterpret_cast<T*>(chunk);
}

Free List Check: If freeList is not null, the allocator retrieves a chunk from the free list.
Placement New: Constructs the object in-place within the chunk, avoiding the need for a secondary allocation.
Dynamic Index Calculation: Uses logarithmic indexing to manage exponential growth.

Chapter 3: Benchmarking the Memory Pool vs. Standard Allocation

To validate the performance benefits, I conducted several benchmarks comparing the memory pool to standard new/delete operations. Tests were conducted across different object counts to observe how each method scales.

Benchmark Setup

Memory Pool Allocation/Deallocation: Measures time for allocation and deallocation in the memory pool.
Standard Allocation/Deallocation: Measures equivalent operations using new and delete.
Memory Pool Reallocation: Reallocates each object after deallocation to test efficiency of memory reuse.
Standard Reallocation: Reallocates each object using standard methods.

Test Sizes: Object counts ranged from 10 to 100 million, allowing us to observe scaling behavior.

Environment: Each operation was timed in nanoseconds using std::chrono. Averages were taken over multiple runs.

Results and Analysis

Allocation and Deallocation

Allocation Time Comparison:

The memory pool demonstrates faster allocation times, especially with large object counts.
Standard allocation time grows quickly with object count due to frequent heap allocations.

Deallocation Time Comparison:

The memory pool performs deallocation efficiently by linking chunks back into the free list, while standard deallocation becomes slower at high object counts.

Reallocation

Reallocation in the memory pool is faster due to its ability to reuse memory blocks, avoiding new heap allocations.

Reallocation Time Comparison:

Memory pool reallocation shows a considerable advantage in speed, especially at large object counts.
Standard reallocation incurs high overhead from continuous heap allocations, making it significantly slower at scale.

Insights and Conclusions

Scalability: The memory pool allocator scales efficiently across large object counts, showing significant time savings in allocation and reallocation.
Efficiency in Reuse: The memory pool is ideal for scenarios requiring frequent allocation and deallocation, such as object pooling in game engines.
Fragmentation Reduction: Managing memory in contiguous chunks reduces fragmentation, enhancing performance compared to standard heap allocation.

These benchmarks illustrate the potential of a custom memory pool allocator to improve memory management in performance-critical applications.

Thanks for reading :)
To view the full code and benchmark data, check out the project repository: PgEngine.
I hope you this article interesting. If so, please consider following me here and on social media.