std::pmr::monotonic_buffer_resource
来自cppreference.com
<tbody>
</tbody>
| 在标头 <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; // 足以适合所有节点
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