8.07 Managing Fixed Arrays of Heap Objects vs Intrusive Lists & Bitmask Memory Pools

1. Fixed Arrays of Pointers

A static array of pointers (Exhibit* exhibits[3]) holds pointers to individually allocated heap objects. While the array container is statically sized on the stack or in BSS, the individual objects reside on the dynamic heap.

2. Multi-Object Deallocation Lifecycle

To prevent memory leaks, every element in the pointer array must be explicitly deleted and reset to nullptr when its lifecycle ends.

1. Out-of-Order Deallocation Fragmentation

If exhibits (or network packets, sensor readings) are allocated and freed in random order, general-purpose heap allocators create fragmented memory holes that cannot be coalesced, eventually causing allocation failure.

2. Fixed-Block Allocator with Bitmask Free-List

A Fixed-Block Allocator pre-allocates $N$ memory blocks of identical size in static SRAM. A single integer bitmask tracks which blocks are free. Allocation and deallocation are $O(1)$ constant time operations with zero fragmentation.

Here is a deterministic, zero-fragmentation Fixed-Block Pool Allocator using a bitmask:

#include <cstdint>
#include <cstddef>
#include <new>

template <typename T, size_t BlockCount = 32>
class FixedBlockPool {
    static_assert(BlockCount <= 32, "Bitmask supports up to 32 blocks");

    alignas(alignof(T)) std::byte memory_[BlockCount][sizeof(T)];
    uint32_t allocation_mask_{0}; // Bit = 1 (Used), Bit = 0 (Free)

public:
    template <typename... Args>
    T* allocate(Args&&... args) noexcept {
        for (size_t i = 0; i < BlockCount; ++i) {
            if (!(allocation_mask_ & (1UL << i))) {
                allocation_mask_ |= (1UL << i); // Mark block as used
                return new (memory_[i]) T(std::forward<Args>(args)...);
            }
        }
        return nullptr; // Out of blocks
    }

    void free(T* ptr) noexcept {
        if (!ptr) return;
        for (size_t i = 0; i < BlockCount; ++i) {
            if (reinterpret_cast<T*>(memory_[i]) == ptr) {
                ptr->~T();
                allocation_mask_ &= ~(1UL << i); // Clear bitmask
                return;
            }
        }
    }
};