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(抽象基类)
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
// 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 等
}基本示例
#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
#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 有运行时开销(虚函数调用),对于极端性能敏感的场景可能不如自定义模板分配器
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 9.0 |
| Clang | 16.0(libstdc++ 依赖 GCC) |
| MSVC | 19.13 (VS 2017 15.6) |
总结
C++17 的 PMR 框架通过运行时多态解决了传统分配器的类型侵入问题。核心思路是:分配策略不再是容器类型的一部分,而是通过 memory_resource 指针在运行时指定。标准提供了几种即用的内存资源实现——monotonic_buffer_resource 适合批量分配后一次性释放的场景(极快),pool_resource 适合频繁分配/释放的场景,new_delete_resource 提供默认的堆分配行为。自定义 memory_resource 只需继承基类并实现三个虚函数,可以很方便地创建跟踪分配器、日志分配器等调试工具。PMR 最大的价值在于:不同分配策略的容器类型相同,可以在同一个接口中使用,而传统分配器做不到这一点。