Namespaces
Variants

std::pmr:: monotonic_buffer_resource

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::pmr::monotonic_buffer_resource
定义于头文件 <memory_resource>
class monotonic_buffer_resource : public std:: pmr :: memory_resource ;
(C++17 起)

类 std::pmr::monotonic_buffer_resource 是一种特殊用途的内存资源类，仅在资源被销毁时才会释放已分配的内存。它适用于需要快速内存分配的场合，即内存被用于构建少量对象后一次性全部释放的场景。

monotonic_buffer_resource 可通过初始缓冲区构建。若未提供初始缓冲区或缓冲区耗尽，则会从构造时提供的 上游内存资源 获取额外缓冲区。所获缓冲区的大小遵循几何级数增长规律。

monotonic_buffer_resource 不是线程安全的。

目录

成员函数

构造一个 monotonic_buffer_resource
(公开成员函数)
[virtual]
销毁 monotonic_buffer_resource ，释放所有已分配内存
(虚公开成员函数)
operator=
[deleted]
复制赋值运算符被删除。 monotonic_buffer_resource 不可复制赋值
(公开成员函数)
公开成员函数
释放所有已分配内存
(公开成员函数)
返回指向上游内存资源的指针
(公开成员函数)
受保护成员函数
[virtual]
分配内存
(虚受保护成员函数)
[virtual]
无操作
(虚受保护成员函数)
[virtual]
与另一个 std::pmr::memory_resource 进行相等性比较
(虚受保护成员函数)

示例

该程序测量使用以下分配器创建大型双向链表所需的时间：

  • 默认标准分配器，
  • 默认 pmr 分配器，
  • 使用单调资源但无显式内存缓冲区的 pmr 分配器，
  • 使用单调资源及外部内存缓冲区（位于栈上）的 pmr 分配器。
运行此代码 
#include <array>
#include <chrono>
#include <cstddef>
#include <iomanip>
#include <iostream>
#include <list>
#include <memory_resource>
template<typename Func>
auto benchmark(Func test_func, int iterations)
{
    const auto start = std::chrono::system_clock::now();
    while (iterations-- > 0)
        test_func();
    const auto stop = std::chrono::system_clock::now();
    const auto secs = std::chrono::duration<double>(stop - start);
    return secs.count();
}
int main()
{
    constexpr int iterations{100};
    constexpr int total_nodes{2'00'000};
    auto default_std_alloc = [total_nodes]
    {
        std::list<int> list;
        for (int i{}; i != total_nodes; ++i)
            list.push_back(i);
    };
    auto default_pmr_alloc = [total_nodes]
    {
        std::pmr::list<int> list;
        for (int i{}; i != total_nodes; ++i)
            list.push_back(i);
    };
    auto pmr_alloc_no_buf = [total_nodes]
    {
        std::pmr::monotonic_buffer_resource mbr;
        std::pmr::polymorphic_allocator<int> pa{&mbr};
        std::pmr::list<int> list{pa};
        for (int i{}; i != total_nodes; ++i)
            list.push_back(i);
    };
    auto pmr_alloc_and_buf = [total_nodes]
    {
        std::array<std::byte, total_nodes * 32> buffer; // 足够容纳所有节点
        std::pmr::monotonic_buffer_resource mbr{buffer.data(), buffer.size()};
        std::pmr::polymorphic_allocator<int> pa{&mbr};
        std::pmr::list<int> list{pa};
        for (int i{}; i != total_nodes; ++i)
            list.push_back(i);
    };
    const double t1 = benchmark(default_std_alloc, iterations);
    const double t2 = benchmark(default_pmr_alloc, iterations);
    const double t3 = benchmark(pmr_alloc_no_buf , iterations);
    const double t4 = benchmark(pmr_alloc_and_buf, iterations);
    std::cout << std::fixed << std::setprecision(3)
              << "t1 (默认 std 分配器): " << t1 << " 秒; t1/t1: " << t1/t1 << '\n'
              << "t2 (默认 pmr 分配器): " << t2 << " 秒; t1/t2: " << t1/t2 << '\n'
              << "t3 (pmr 分配器 无缓冲区): " << t3 << " 秒; t1/t3: " << t1/t3 << '\n'
              << "t4 (pmr 分配器 有缓冲区): " << t4 << " 秒; t1/t4: " << t1/t4 << '\n';
}

可能的