std::pmr::memory_resource 与多态分配器 ​

什么是 pmr(Polymorphic Memory Resource) ​

C++17 在 <memory_resource> 头文件中引入了一套基于运行时多态的内存分配框架,统称为 PMR(Polymorphic Memory Resource)。这套框架的核心是 std::pmr::memory_resource 抽象基类和 std::pmr::polymorphic_allocator 分配器。

传统的 C++ 分配器(std::allocator)是基于模板的静态多态——分配器类型是容器类型的一部分。这意味着 std::vector<int, MyAllocator> 和 std::vector<int, std::allocator<int>> 是完全不同的类型,不能互相赋值、不能放在同一个容器里、不能传递给接受另一种分配器的函数。

PMR 通过运行时多态解决了这个问题:所有使用 pmr::polymorphic_allocator 的容器类型相同(比如 std::pmr::vector<int>),不同的内存分配策略通过指向不同 memory_resource 对象的指针来切换。你可以在运行时决定使用栈上的缓冲区、内存池、还是默认的堆分配,而不影响容器的类型。

核心组件 ​

memory_resource(抽象基类) ​

cpp
class memory_resource {
public:
    virtual ~memory_resource();
    void* allocate(std::size_t bytes, std::size_t alignment = alignof(std::max_align_t));
    void deallocate(void* p, std::size_t bytes, std::size_t alignment = alignof(std::max_align_t));
    bool is_equal(const memory_resource& other) const noexcept;

protected:
    // 派生类需要实现这三个虚函数
    virtual void* do_allocate(std::size_t bytes, std::size_t alignment) = 0;
    virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) = 0;
    virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
};

标准提供的 memory_resource 实现 ​

类型说明
std::pmr::new_delete_resource()使用全局 new/delete 的默认资源
std::pmr::null_memory_resource()任何分配都抛异常(用于测试)
std::pmr::monotonic_buffer_resource单调递增分配,不支持单独释放,销毁时一次性释放全部内存
std::pmr::synchronized_pool_resource线程安全的内存池
std::pmr::unsynchronized_pool_resource非线程安全的内存池(单线程更快)

polymorphic_allocator ​

cpp
// pmr 容器的类型别名
namespace std::pmr {
    template<class T> using vector = std::vector<T, polymorphic_allocator<T>>;
    template<class T> using list = std::list<T, polymorphic_allocator<T>>;
    using string = std::basic_string<char, std::char_traits<char>, polymorphic_allocator<char>>;
    // ... 以及 map, set, deque, unordered_map 等
}

基本示例 ​

cpp
#include <iostream>
#include <memory_resource>
#include <vector>
#include <string>
#include <array>
#include <list>

// ============================
// 示例1:使用 monotonic_buffer_resource(栈上缓冲区)
// ============================

void monotonic_demo() {
    // 在栈上分配 1024 字节的缓冲区
    std::array<std::byte, 1024> buffer;

    // 创建单调缓冲区资源,使用栈上的 buffer
    // 当 buffer 用完时,回退到 new_delete_resource
    std::pmr::monotonic_buffer_resource pool{
        buffer.data(), buffer.size(),
        std::pmr::new_delete_resource()  // 上游资源(buffer 不够时使用)
    };

    // 使用这个资源的 vector
    std::pmr::vector<int> vec{&pool};

    // 所有分配都来自栈上的 buffer,不触发 new
    for (int i = 0; i < 100; ++i) {
        vec.push_back(i);
    }

    std::cout << "vector 大小: " << vec.size() << std::endl;
    std::cout << "vector 容量: " << vec.capacity() << std::endl;

    // pool 销毁时一次性释放所有内存(这里是栈上缓冲区,无需释放)
    // 注意:monotonic_buffer_resource 不支持单独释放,
    // deallocate 是空操作(no-op)
}

// ============================
// 示例2:不同资源,相同类型
// ============================

void same_type_demo() {
    // 两个不同的内存资源
    std::pmr::monotonic_buffer_resource pool1;
    std::pmr::monotonic_buffer_resource pool2;

    // 类型完全相同!都是 std::pmr::vector<int>
    std::pmr::vector<int> vec1{&pool1};
    std::pmr::vector<int> vec2{&pool2};

    vec1.push_back(1);
    vec2.push_back(2);

    // 可以传给同一个函数
    auto print = [](const std::pmr::vector<int>& v) {
        for (auto x : v) std::cout << x << " ";
        std::cout << std::endl;
    };

    print(vec1);
    print(vec2);

    // 对比传统分配器:
    // std::vector<int, AllocA> 和 std::vector<int, AllocB> 是不同类型
    // 不能传给同一个函数(除非用模板)
}

// ============================
// 示例3:pmr::string 自动使用容器的资源
// ============================

void string_propagation_demo() {
    std::array<std::byte, 4096> buffer;
    std::pmr::monotonic_buffer_resource pool{
        buffer.data(), buffer.size()
    };

    // pmr::vector<pmr::string> 中的 string 也会使用 vector 的内存资源
    std::pmr::vector<std::pmr::string> names{&pool};

    names.emplace_back("Alice");
    names.emplace_back("Bob");
    names.emplace_back("Charlie with a very long name that exceeds SSO");

    // 所有 string 的内存都来自栈上的 buffer
    for (const auto& name : names) {
        std::cout << name << std::endl;
    }
}

// ============================
// 示例4:synchronized_pool_resource(内存池)
// ============================

void pool_demo() {
    // 内存池选项
    std::pmr::pool_options opts;
    opts.max_blocks_per_chunk = 100;     // 每次从上游分配的最大块数
    opts.largest_required_pool_block = 256; // 池化的最大块大小

    // 创建线程安全的内存池
    std::pmr::synchronized_pool_resource pool{opts};

    // 使用内存池的 list(list 频繁小块分配,内存池效果好)
    std::pmr::list<int> lst{&pool};
    for (int i = 0; i < 1000; ++i) {
        lst.push_back(i);
    }

    std::cout << "list 大小: " << lst.size() << std::endl;

    // pool 销毁时释放所有内存块
}

int main() {
    std::cout << "=== monotonic_buffer_resource ===" << std::endl;
    monotonic_demo();

    std::cout << "\n=== 相同类型不同资源 ===" << std::endl;
    same_type_demo();

    std::cout << "\n=== string 资源传播 ===" << std::endl;
    string_propagation_demo();

    std::cout << "\n=== pool_resource ===" << std::endl;
    pool_demo();

    return 0;
}

自定义 memory_resource ​

cpp
#include <iostream>
#include <memory_resource>
#include <vector>
#include <cstdlib>

// ============================
// 自定义跟踪分配器:记录所有分配和释放操作
// ============================

class tracking_resource : public std::pmr::memory_resource {
    std::string name_;
    std::pmr::memory_resource* upstream_;  // 实际干活的上游资源
    std::size_t total_allocated_ = 0;
    std::size_t total_deallocated_ = 0;
    int alloc_count_ = 0;

public:
    tracking_resource(std::string name,
                      std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
        : name_(std::move(name)), upstream_(upstream) {}

    ~tracking_resource() {
        std::cout << "[" << name_ << "] 总分配: " << total_allocated_
                  << " 字节, 总释放: " << total_deallocated_
                  << " 字节, 分配次数: " << alloc_count_ << std::endl;
    }

protected:
    void* do_allocate(std::size_t bytes, std::size_t alignment) override {
        void* ptr = upstream_->allocate(bytes, alignment);
        total_allocated_ += bytes;
        ++alloc_count_;
        std::cout << "[" << name_ << "] 分配 " << bytes
                  << " 字节 (align=" << alignment << ") -> " << ptr << std::endl;
        return ptr;
    }

    void do_deallocate(void* ptr, std::size_t bytes, std::size_t alignment) override {
        std::cout << "[" << name_ << "] 释放 " << bytes
                  << " 字节 <- " << ptr << std::endl;
        total_deallocated_ += bytes;
        upstream_->deallocate(ptr, bytes, alignment);
    }

    bool do_is_equal(const memory_resource& other) const noexcept override {
        return this == &other;
    }
};

void custom_resource_demo() {
    tracking_resource tracker{"my_tracker"};

    std::pmr::vector<int> vec{&tracker};
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);

    // 输出会显示 vector 扩容时的分配/释放过程
}

int main() {
    custom_resource_demo();
    return 0;
}

各种 memory_resource 的对比 ​

资源类型分配速度释放方式线程安全适用场景
new_delete_resource一般逐个释放是默认行为,通用
null_memory_resource永远失败N/A是测试、确保不分配
monotonic_buffer_resource极快只能全部释放否批量创建后一次性销毁
synchronized_pool_resource快逐个释放到池中是多线程频繁分配/释放
unsynchronized_pool_resource更快逐个释放到池中否单线程频繁分配/释放

适用场景 ​

  • 性能敏感的内存分配:用 monotonic_buffer_resource 在栈上预分配缓冲区,避免堆分配
  • 批处理任务:创建大量临时对象,处理完一次性销毁(monotonic 最适合)
  • 游戏开发中的帧分配器:每帧开始时重置 monotonic buffer,该帧所有临时分配都从中获取
  • 需要在运行时切换分配策略而不改变容器类型的场景
  • 内存分配调试和追踪:自定义 memory_resource 记录所有分配
  • 嵌入式系统:预分配固定大小的内存,完全避免动态堆分配

常见问题 ​

pmr 容器和普通容器可以互相赋值吗?

不能直接赋值。std::pmr::vector<int> 和 std::vector<int> 是不同类型。但可以通过迭代器范围构造或赋值来转换数据。pmr 容器之间(即使使用不同的 memory_resource)可以赋值,因为它们的类型相同。

monotonic_buffer_resource 的 deallocate 做了什么?

什么都不做(no-op)。monotonic 的设计就是只分配不释放,所有内存在资源对象销毁时一次性释放。这就是它分配速度极快的原因——分配只是移动一个指针。

pmr::string 存在 pmr::vector 里时,string 的内存从哪里来?

如果 string 支持分配器传播(pmr::string 支持),它会自动使用 vector 的内存资源。这是 PMR 的一个核心优势:嵌套容器可以共享同一个内存资源。

什么时候用 synchronized 什么时候用 unsynchronized pool?

如果只在单线程中使用,用 unsynchronized_pool_resource 更快(没有加锁开销)。如果多个线程共享同一个 pool,用 synchronized_pool_resource。

注意事项 ​

  • monotonic_buffer_resource 不是线程安全的,多线程环境下需要自己加锁或每个线程用一个
  • pmr 容器的类型是固定的(比如 std::pmr::vector<int>),不需要也不能指定分配器模板参数
  • memory_resource 对象的生命周期必须长于所有使用它的容器
  • 自定义 memory_resource 时,do_allocate 分配失败必须抛 std::bad_alloc,不能返回 nullptr
  • set_default_resource 会影响全局,谨慎使用
  • PMR 有运行时开销(虚函数调用),对于极端性能敏感的场景可能不如自定义模板分配器

编译器支持情况 ​

编译器最低支持版本
GCC9.0
Clang16.0(libstdc++ 依赖 GCC)
MSVC19.13 (VS 2017 15.6)

总结 ​

C++17 的 PMR 框架通过运行时多态解决了传统分配器的类型侵入问题。核心思路是:分配策略不再是容器类型的一部分,而是通过 memory_resource 指针在运行时指定。标准提供了几种即用的内存资源实现——monotonic_buffer_resource 适合批量分配后一次性释放的场景(极快),pool_resource 适合频繁分配/释放的场景,new_delete_resource 提供默认的堆分配行为。自定义 memory_resource 只需继承基类并实现三个虚函数,可以很方便地创建跟踪分配器、日志分配器等调试工具。PMR 最大的价值在于:不同分配策略的容器类型相同,可以在同一个接口中使用,而传统分配器做不到这一点。