Designing a High‑Performance Custom Memory Pool for C++17 and Beyond

作者

随着多核 CPU 的普及和游戏、金融等领域对低延迟的极致追求，自定义内存池已经成为许多高性能项目的必备工具。本文将从设计原则、实现细节以及性能调优四个层面，系统介绍如何在 C++17 及更高版本中实现一个可复用、线程安全且易于维护的内存池。

1. 设计原则

  1. 分块对齐 – 采用 std::aligned_storage_t 或 alignas 确保每个块的对齐满足目标类型的对齐要求。
  2. 固定大小分配 – 对于大多数内存池，固定块大小可以大幅降低碎片。若需要多种尺寸，可采用分级池或层次化池。
  3. 线程安全 – 使用 std::atomic 或 std::mutex 控制并发访问；对于高频访问，可考虑无锁链表或分区锁。
  4. 可扩展性 – 当池已满时动态分配新一块内存（std::pmr::monotonic_buffer_resource 或自定义分配器）。
  5. 回收机制 – 采用自由链表（free list）方式快速回收，避免重复调用 operator new/delete。

2. 基础实现示例

下面给出一个简单但完整的示例，演示如何在 C++17 中实现一个线程安全、固定块大小的内存池。代码使用了 std::alignas、std::atomic 和 std::thread 进行演示。 

#include <cstddef>
#include <cstdint>
#include <memory>
#include <atomic>
#include <vector>
#include <mutex>
#include <cassert>
#include <iostream>
#include <thread>

template<std::size_t BlockSize, std::size_t BlockCount>
class FixedBlockPool {
public:
    FixedBlockPool() {
        static_assert(BlockSize >= sizeof(Node), "BlockSize too small");
        // Allocate a contiguous memory region
        buffer_ = std::unique_ptr<std::uint8_t[]>(new std::uint8_t[BlockSize * BlockCount]);

        // Initialize free list
        for (std::size_t i = 0; i < BlockCount; ++i) {
            Node* node = reinterpret_cast<Node*>(buffer_.get() + i * BlockSize);
            node->next = freeList_;
            freeList_ = node;
        }
    }

    void* allocate() {
        Node* node = freeList_.load(std::memory_order_acquire);
        while (node) {
            if (freeList_.compare_exchange_weak(node, node->next,
                                                std::memory_order_release,
                                                std::memory_order_relaxed)) {
                return node;
            }
        }
        // Pool exhausted
        return nullptr;
    }

    void deallocate(void* ptr) {
        if (!ptr) return;
        Node* node = static_cast<Node*>(ptr);
        node->next = freeList_.load(std::memory_order_relaxed);
        freeList_.store(node, std::memory_order_release);
    }

private:
    struct Node {
        Node* next;
    };

    std::unique_ptr<std::uint8_t[]> buffer_;
    std::atomic<Node*> freeList_{nullptr};
};

int main() {
    constexpr std::size_t BLOCK_SIZE = 64;
    constexpr std::size_t BLOCK_COUNT = 1'024'000; // ~64 MB pool

    FixedBlockPool<BLOCK_SIZE, BLOCK_COUNT> pool;

    // Single‑thread test
    void* ptr = pool.allocate();
    assert(ptr);
    pool.deallocate(ptr);

    // Multi‑thread test
    const std::size_t thread_count = std::thread::hardware_concurrency();
    std::vector<std::thread> workers;
    for (std::size_t i = 0; i < thread_count; ++i) {
        workers.emplace_back([&pool]() {
            for (int n = 0; n < 10'000; ++n) {
                void* p = pool.allocate();
                if (p) {
                    // Simulate work
                    std::this_thread::yield();
                    pool.deallocate(p);
                }
            }
        });
    }
    for (auto& t : workers) t.join();

    std::cout << "Memory pool demo finished.\n";
    return 0;
}

关键点说明

  1. 节点结构：Node 只包含指向下一空闲块的指针，最小化块内部开销。
  2. 无锁分配：使用 compare_exchange_weak 对 freeList_ 进行 CAS，避免使用互斥锁。
  3. 内存对齐：BLOCK_SIZE 必须满足对齐要求（可通过 alignas 进一步控制）。
  4. 池满处理：本示例返回 nullptr；实际项目可扩展为动态增长。

3. 性能调优技巧

调优项 方法 说明
分区锁 每个线程/核心维护自己的小池 减少全局 CAS 竞争
缓存行对齐 alignas(64) 避免跨缓存行访问导致的冲突
批量分配 预先分配若干块 减少每次分配的系统调用次数
内存回收 延迟回收，批量放回 减少频繁的 free 产生的碎片
使用 std::pmr 通过 polymorphic_allocator 兼容标准库容器，提高灵活性

4. 与标准库分配器的整合

C++17 引入了 std::pmr（Polymorphic Memory Resources），可以轻松将自定义内存池与 STL 容器配合使用。下面给出一个简化示例：

#include <memory_resource>
#include <vector>

int main() {
    constexpr std::size_t POOL_SIZE = 1024 * 1024 * 64; // 64 MB
    std::vector<std::uint8_t> buffer(POOL_SIZE);
    std::pmr::monotonic_buffer_resource pool(buffer.data(), POOL_SIZE);

    std::pmr::vector <int> v(&pool);
    v.reserve(1000);
    for (int i = 0; i < 1000; ++i) v.push_back(i);
}

若你需要更细粒度的控制，可以继承 std::pmr::memory_resource 并实现 do_allocate, do_deallocate, do_is_equal。这样，你的自定义内存池就能无缝替换任何使用 std::pmr::memory_resource 的 STL 容器。

5. 实际应用场景

场景 需求 内存池优势
游戏引擎 频繁创建/销毁实体 减少堆碎片、提升帧率
高频交易 极低延迟内存分配 缩短 GC 或重分配时间
嵌入式系统 内存受限、确定性 固定块大小可避免碎片
网络服务器 大量短生命周期请求 快速回收减少系统调用

6. 结语

自定义内存池是 C++ 性能优化的重要工具。通过结合现代语言特性（如 std::atomic, std::pmr），可以构建既安全又高效的内存管理方案。希望本文的示例和调优思路能为你在项目中实现稳定、可扩展的内存池提供参考。祝编码愉快！

发表评论