命名空间
变体
操作

std::pmr::monotonic_buffer_resource

来自 cppreference.com
< cpp‎ | memory
 
C++
 
动态内存管理
未初始化内存算法
受约束的未初始化内存算法
分配器
垃圾收集支持
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 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
(公有成员函数) [编辑]
[虚拟]
 销毁 monotonic_buffer_resource，释放所有已分配的内存
(虚拟公有成员函数) [编辑]
operator=
[已删除]
 复制赋值运算符已被删除。monotonic_buffer_resource 不可复制赋值
(公有成员函数) [编辑]
公有成员函数
 释放所有已分配的内存
(公有成员函数) [编辑]
 返回指向上游内存资源的指针
(公有成员函数) [编辑]
保护成员函数
[虚拟]
 分配内存
(虚拟保护成员函数) [编辑]
[虚拟]
 无操作
(虚拟保护成员函数) [编辑]
[虚拟]
 与另一个 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; // enough to fit in all nodes
        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 (default std alloc): " << t1 << " sec; t1/t1: " << t1/t1 << '\n'
              << "t2 (default pmr alloc): " << t2 << " sec; t1/t2: " << t1/t2 << '\n'
              << "t3 (pmr alloc  no buf): " << t3 << " sec; t1/t3: " << t1/t3 << '\n'
              << "t4 (pmr alloc and buf): " << t4 << " sec; t1/t4: " << t1/t4 << '\n';
}

可能的输出

t1 (default std alloc): 0.720 sec; t1/t1: 1.000
t2 (default pmr alloc): 0.915 sec; t1/t2: 0.787
t3 (pmr alloc  no buf): 0.370 sec; t1/t3: 1.945
t4 (pmr alloc and buf): 0.247 sec; t1/t4: 2.914
Retrieved from "https://cppreference.cn/mwiki/index.php?title=cpp/memory/monotonic_buffer_resource&oldid=152966"