Skip to main content

Chapter 46: PMR

核心问题与阅读主线

本章导读5 个核心小节 · 附自检与总结

PMR(Polymorphic Memory Resource,C++17 <memory_resource>)把 STL 容器的分配策略从模板类型参数移至运行时 std::pmr::memory_resource*,消除了自定义 allocator 带来的容器类型分裂。代价是资源寿命与跨边界传播不再由编译器把关,工程核心变成守住资源生存期、嵌套元素传播以及拷贝/移动/交换时的资源一致性。

全章共用代码样本(下文各节持续拆解)

贯穿材料核心代码

本章贯穿材料是一组“请求解析器”临时对象:单次解析需保存字段名、字段值及中间字符串,请求结束时整体销毁;后续还会延伸到解析中途增删字段与跨容器传递场景。

#include <memory_resource>
#include <string>
#include <string_view>
#include <vector>

struct Field {
std::pmr::string name;
std::pmr::string value;

Field(std::string_view n,
std::string_view v,
std::pmr::memory_resource* resource)
: name(n.data(), n.size(), resource),
value(v.data(), v.size(), resource) {}
};

struct RequestScratch {
std::pmr::vector<Field> fields;

explicit RequestScratch(std::pmr::memory_resource* resource)
: fields(resource) {}

void add_field(std::string_view name, std::string_view value) {
fields.emplace_back(name, value, fields.get_allocator().resource());
}
};

46.1 memory_resource 与 allocator 多态化​

std::pmr::memory_resource 是 C++17 定义的运行时分配抽象基类,派生类通过覆盖 do_allocate、do_deallocate 与 do_is_equal 完成按字节和对齐分配、原始内存归还以及资源等价判定。

传统模板 allocator 把策略写进静态类型,而 PMR 把策略统一为 std::pmr::polymorphic_allocator<T>(内部仅保存一个 std::pmr::memory_resource*):

维度传统模板 Allocator(如 std::vector<int, PoolAlloc<int>>)PMR(如 std::pmr::vector<int>)
静态类型与 ABI策略绑定进容器类型,与 std::vector<int> 不互通容器类型统一,可跨模块与接口稳定传递
策略切换时机编译期模板实例化决定运行时构造时注入 memory_resource*
运行期开销通常无间接分派开销经由虚函数表分派到具体 memory_resource

贯穿代码中的 RequestScratch 拆开了两层职责:

  • 容器层(RequestScratch 与 std::pmr::vector<Field>):负责元素生命周期,即构造、移动与销毁 Field。
  • 资源层(memory_resource):只负责按大小与对齐交付并收回原始内存;元素析构与内存归还属于两个独立动作,PMR 仅改变后者的来源与策略。

边界与误区

注意

容器与 polymorphic_allocator 仅持有非拥有指针 memory_resource*,资源对象寿命必须覆盖所有依赖它的容器与嵌套元素。一旦资源先销毁,容器后续析构、扩容、清空或赋值都会触碰悬垂指针;寿命正确性优先级高于性能优化。

  • 嵌套透传:std::pmr::polymorphic_allocator 支持 uses-allocator construction,可把同一个 memory_resource* 自动透传给支持 PMR 的元素。
  • 默认资源边界:std::pmr::get_default_resource()、std::pmr::set_default_resource() 与 std::pmr::new_delete_resource() 影响默认构造的 PMR allocator;业务代码应优先显式传入资源,仅在进程或框架边界集中配置默认资源,避免把它当作局部性能调优开关。

46.2 monotonic_buffer_resource​

std::pmr::monotonic_buffer_resource 通过推进内部偏移量完成 do_allocate,无需维护空闲块链表,自身不提供线程安全保证(缓冲耗尽后的上游增长策略由标准库实现决定):

  • 分配与回收:单次 deallocate 通常无实际释放效果,所有已分配缓冲直到 release() 或资源析构才统一回收。
  • 场景匹配:单次请求解析中字段、临时 token 与中间字符串在请求结束时同批销毁,分配路径极短且局部性稳定。
#include <array>
#include <cstddef>
#include <memory_resource>

void parse_one_request(std::string_view raw) {
std::array<std::byte, 4096> buffer{};
std::pmr::monotonic_buffer_resource arena{
buffer.data(),
buffer.size(),
std::pmr::new_delete_resource()
};

RequestScratch scratch{&arena};
scratch.add_field("method", "GET");
scratch.add_field("path", raw);

// 使用 scratch 完成解析、校验和路由匹配。
}

该示例的安全性依赖三条边界:

  • 初始缓冲:buffer 承接小请求的大部分分配,避免频繁进入堆分配器。
  • 上游兜底:初始缓冲耗尽后,arena 向上游 std::pmr::new_delete_resource() 申请更大缓冲。
  • 析构顺序:局部变量逆序析构保证 scratch 先销毁对象,arena 再收回缓冲。

若要在循环中复用同一 arena,可在每轮末尾调用 release() 释放上游缓冲并复位偏移量:

void parse_many_requests(const std::string_view* first,
const std::string_view* last) {
std::array<std::byte, 8192> buffer{};
std::pmr::monotonic_buffer_resource arena{buffer.data(), buffer.size()};

for (auto it = first; it != last; ++it) {
std::string_view raw = *it;
{
RequestScratch scratch{&arena};
scratch.add_field("path", raw);
// 使用 scratch 完成本轮处理。
}

arena.release();
}
}

边界与误区

注意

release() 只复位与归还原始内存,不会替存活对象执行析构函数。循环复用时必须用内层作用域确保 scratch 先析构再调用 arena.release();顺序颠倒后代码仍能编译,但容器析构会访问已释放存储并引发运行时未定义行为。

核心判断

选用 monotonic_buffer_resource 需确认四件事:对象是否在同一阶段批量销毁(不适合长期随机删除或缩容归还场景,峰值会驻留到 release());阶段峰值是否可估;初始缓冲是否覆盖常见路径(过小频繁走上游,过大抬高常驻内存);以及上游资源是否匹配兜底成本。

46.3 pool resource 系列​

当对象大小集中且分配与归还交错发生时,应选用池化资源:std::pmr::unsynchronized_pool_resource 与 std::pmr::synchronized_pool_resource。二者均从上游取得 chunk 并按尺寸分级切分 block,超大块直接走上游,析构时释放全部已分配内存,并可用 std::pmr::pool_options 调节池化块尺寸上限与 chunk 参数。

资源类型deallocate 语义线程安全保证典型成本与内存特征适用场景
monotonic_buffer_resource通常不实际回收无路径最短,内存保留到 release() 或析构同阶段批量创建、整体销毁
unsynchronized_pool_resource块回收到对应尺寸池复用无无锁开销,需维护各尺寸池空闲链表单线程解析器、线程局部工作区
synchronized_pool_resource块回收到池复用多线程安全访问含锁、原子或线程专属池分流成本多线程共享同一资源对象

如果请求解析器需要在处理中途增删、归一化字段(大小集中在 Field、字符串外溢块与 vector 扩容块),deallocate 归还的小块可立即被后续同类请求复用:

#include <memory_resource>

void normalize_request(std::string_view raw) {
std::pmr::unsynchronized_pool_resource pool;
RequestScratch scratch{&pool};

scratch.add_field("path", raw);
scratch.add_field("cache-control", "no-cache");

// 处理中可能删除旧字段、插入新字段,归还的小块可被 pool 复用。
}

核心判断

pool resource 的并发边界取决于资源对象是否跨线程共享,而非容器类型:每线程持有独立资源时优先用 unsynchronized_pool_resource;多线程同时向同一资源申请或归还内存时,再选用 synchronized_pool_resource 或外层同步。资源线程安全仅保护分配接口,不保护同一容器的并发修改。

调节 pool_options 前应先校准尺寸跨度与池寿命:分配大小跨度过大时,冷门尺寸池会留存难以复用的 chunk;长期存活的 pool 会记住历史高水位峰值,可按连接、请求批次、线程或任务阶段切分资源寿命,避免局部池变成常驻峰值仓库。

46.4 pmr::vector 与 pmr::string​

std::pmr::vector<T> 是 std::vector<T, std::pmr::polymorphic_allocator<T>> 的别名,std::pmr::string 是使用 std::pmr::polymorphic_allocator<char> 的 std::basic_string 别名。二者完整保留标准容器的连续存储(std::vector 的 data()、扩容重分配、迭代器失效与异常安全承诺)及字符串语义,PMR 仅改变原始存储来源与 allocator 传播边界。

关键事实

std::pmr::string 通常存在短字符串优化(SSO,属实现细节):未超过 SSO 阈值的短字符串不会向 memory_resource 申请内存,较长或扩容后的字符串才会触发资源分配。判断内存路径应依据字符串长度与分配统计,而非假设所有 pmr::string 都经过资源。

当容器元素本身也是 PMR 类型时,polymorphic_allocator 的 uses-allocator construction 会把同一资源透传给元素内部:

#include <array>
#include <cstddef>
#include <memory_resource>
#include <string>
#include <vector>

std::pmr::vector<std::pmr::string>
make_tokens(std::string_view line, std::pmr::memory_resource* resource) {
std::pmr::vector<std::pmr::string> tokens{resource};

tokens.emplace_back(line.substr(0, 4), resource);
tokens.emplace_back(line.substr(5), resource);

return tokens;
}

void use_tokens(std::string_view line) {
std::array<std::byte, 2048> buffer{};
std::pmr::monotonic_buffer_resource arena{buffer.data(), buffer.size()};

auto tokens = make_tokens(line, &arena);
// tokens 的 vector 存储和长字符串字符存储都指向 arena。
}

上例显式向 emplace_back 传入 resource 以展示资源流向;即便省略该实参写为 tokens.emplace_back(...),polymorphic_allocator 仍会通过 uses-allocator construction 让 tokens 与元素 pmr::string 共用 arena。

由于静态类型抹去了资源差异,同类型的两个 std::pmr::vector<std::pmr::string> 在运行时仍可能指向不同资源。容器关键操作的传播边界如下:

容器操作Allocator 是否沿用源容器运行时资源行为与风险边界
拷贝构造(auto b = a)否(调用默认构造)绑定当前 get_default_resource();需指定资源时应显式传 allocator
移动构造(auto b = std::move(a))是(随源移动)b 沿用 a 的 memory_resource* 并接管底层存储
拷贝赋值(b = a)否(不传播)b 保留自身资源指针,按自身资源分配或复用存储
移动赋值(b = std::move(a))否(不传播)资源等价时接管存储;若 is_equal 为假则逐元素移动且可能抛异常
交换(swap(a, b))否(不传播)若两端 allocator 不等价,直接构成未定义行为(UB)
void resource_boundary() {
std::pmr::monotonic_buffer_resource left_arena;
std::pmr::monotonic_buffer_resource right_arena;

std::pmr::vector<std::pmr::string> left{&left_arena};
std::pmr::vector<std::pmr::string> right{&right_arena};

left.emplace_back("left");
right.emplace_back("right");

// 交换、赋值和跨模块返回前,先比较 allocator.resource() 的关系。
const bool same_resource =
left.get_allocator().resource()->is_equal(*right.get_allocator().resource());
(void)same_resource;
}

边界与误区

注意

跨模块 API 接收或返回 PMR 容器时,必须把资源约定写入接口契约:由调用方传入资源、被调用方仅在调用期使用回调或 view 消费、返回对象携带仍存活的外部资源,或在返回前复制到调用方指定的资源中。

46.5 工程使用场景​

当模块需要在普通堆、请求 arena、线程局部池或插件提供的内存之间切换策略,且要求容器类型稳定时,应通过工作区上下文(如 request context、compilation context、format context)显式注入 std::pmr::memory_resource*,让资源的创建点、使用点与释放点清晰可见。

  • 典型匹配场景:请求解析、编译器语法树/IR 局部阶段、日志格式化缓冲、协议解码与一次性 JSON 构建等短生命周期批量对象;插件边界可由宿主注入资源指针,若结果返回宿主长期持有,宿主必须保证资源存活,否则应改为回调或 view 消费。
  • 调优收益与代价:收益来自减少系统分配次数、改善小对象局部性、缩短释放路径与消除 allocator 模板膨胀;代价包括虚函数间接调用、同步池锁成本、池内保留内存与阶段峰值驻留。调优前应先采集分配热点、尺寸分布、线程访问与寿命数据。

按内存模式选型的落地映射如下:

业务内存模式首选资源方案关键约束与关注点
阶段统一释放monotonic_buffer_resource将资源寿命绑定到请求、任务或批次,评估峰值内存
小块频繁复用(单线程)unsynchronized_pool_resource先切分池寿命与业务阶段,再按尺寸分布调 pool_options
跨线程共享资源synchronized_pool_resource(或外部同步)存在同步开销,且不提供单容器并发修改保护
普通兼容/兜底路径std::pmr::new_delete_resource() 或默认资源行为接近普通堆分配,适合作为对照基准
观测与边界测试自定义 memory_resource拦截 do_allocate/do_deallocate 记录次数、字节与热点

自定义 memory_resource 可对容器透明注入观测、限额或专用分配器逻辑:

#include <cstddef>
#include <memory_resource>

class CountingResource : public std::pmr::memory_resource {
public:
explicit CountingResource(std::pmr::memory_resource* upstream)
: upstream_(upstream) {}

std::size_t allocated_bytes() const noexcept {
return allocated_bytes_;
}

private:
void* do_allocate(std::size_t bytes, std::size_t alignment) override {
allocated_bytes_ += bytes;
return upstream_->allocate(bytes, alignment);
}

void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override {
upstream_->deallocate(p, bytes, alignment);
}

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

std::pmr::memory_resource* upstream_{};
std::size_t allocated_bytes_{};
};

工程化实现自定义观测资源时,还需补齐线程安全、计数溢出、异常安全路径与日志采样开销控制。

排查顺序

落地或排查 PMR 代码按五步核对:

  1. 确认对象生命周期是否有明确阶段边界。
  2. 统计分配尺寸分布与释放交错模式。
  3. 选定 monotonic、非同步 pool、同步 pool 或普通堆资源。
  4. 核实资源寿命是否覆盖所有绑定容器及嵌套 PMR 对象。
  5. 检查拷贝、移动、交换与跨模块返回是否越过不等价资源边界。

最小自检任务​

动手自检先独立判断

阅读下面代码,判断 tokens、copied 和 moved 的内存资源关系,并说明这段代码在工程上需要检查哪些边界。

#include <array>
#include <cstddef>
#include <memory_resource>
#include <string>
#include <vector>

std::pmr::vector<std::pmr::string>
make_words(std::pmr::memory_resource* resource) {
std::pmr::vector<std::pmr::string> words{resource};
words.emplace_back("alpha");
words.emplace_back("beta-beta-beta-beta-beta");
return words;
}

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

auto tokens = make_words(&arena);
auto copied = tokens;
auto moved = std::move(tokens);

(void)copied;
(void)moved;
}

本章知识点总结​

  • 运行时策略

    PMR 用 std::pmr::memory_resource* 替代编译期 allocator 模板参数,保留 std::pmr::vector<T> 等统一容器类型。

  • 两层职责

    容器负责元素构造、移动、销毁、迭代器失效与复杂度承诺,memory_resource 只负责原始内存的分配、归还与等价判定。

  • 寿命底线

    容器与 polymorphic_allocator 只持非拥有指针,资源寿命必须严格覆盖所有绑定容器及其嵌套 PMR 元素。

  • monotonic 资源

    monotonic_buffer_resource 跳过单次 deallocate,在 release() 或析构时整批回收;调用 release() 前必须先销毁所有存活对象。

  • pool 资源与并发

    unsynchronized_pool_resource(单线程)与 synchronized_pool_resource(跨线程共享资源)按尺寸分级复用小块,但资源线程安全不等于容器并发写安全。

  • 嵌套与 SSO

    std::pmr::vector<std::pmr::string> 通过 uses-allocator construction 向元素传播资源,pmr::string 在短字符串优化(SSO)范围内可能不向资源分配。

  • 赋值与交换边界

    polymorphic_allocator 拷贝构造绑定 get_default_resource(),且在拷贝赋值、移动赋值与 swap 中均不传播;异资源容器 swap 为未定义行为,异资源移动赋值可能分配并抛异常。