c++ - pmr::vector 比 std::vector 慢

Question

我写了一个简单的benchmark 看看使用 pmr::vector 与 std::vector 相比有什么好处。
在 benchmarks 中， pmr::vector 使用 n unsynchronized_pool_resource 。作为上游，也使用单调缓冲区。
看看基准代码

#include <iostream>
#include <memory_resource>
#include <chrono>
#include <functional>

static void pmrVector(benchmark::State& state)
{
   constexpr size_t BUF_SIZE = 2048;
   std::pmr::pool_options options;
   options.max_blocks_per_chunk = 4;
   options.largest_required_pool_block = 64;
   
    alignas(8) std::array<char,BUF_SIZE> buffer; // a small buffer on the stack
  
    //std::cout <<options.largest_required_pool_block << std::endl;
   std::pmr::monotonic_buffer_resource pool{std::data(buffer), std::size(buffer)};
  std::pmr::unsynchronized_pool_resource mem (options,&pool);
  for (auto _ : state) 
  {
    
    std::pmr::vector<char> vec{ &mem };
    for(char i = 'a'; i < 'z';++i)
    {
            
            vec.emplace_back(i);
            benchmark::DoNotOptimize(vec);
            
    }

    
  }
}
static void stdVector(benchmark::State& state)
{
   
   for (auto _ : state) 
   {
      std::vector<char> vec{};
      for(char i = 'a'; i < 'z';++i)
      {
            
            vec.emplace_back(i);
            benchmark::DoNotOptimize(vec);
            
      }
   }
}
BENCHMARK(pmrVector);
BENCHMARK(stdVector);

pmr::vector 比 std::vector 慢 3 倍。与单调缓冲区相比， unsynchronized_pool_resource 似乎有巨大的惩罚。
看看这个基准 benchmark monotonic buffer only
使用 unsynchronized_pool_resource 的性能比较

查看仅使用单调缓冲区的性能比较

Answer 1

你必须非常小心你真正的时间安排。
我对你的测试做了一些合理的更改，我可以看到改进，可能主要是因为不需要使用系统范围的分配。
(PMR 的优势不止于此。)

测试更多元素

由于您需要测试更多元素，因此不要使用堆栈缓冲区:使用单个分配并且不要测量它。

重置内存资源，否则你会因为重复测试循环而溢出单调资源，从而错误地使用内存资源。

通过所有这些变化，我得到了更预期的结果。
https://quick-bench.com/q/ylppu2cug3S25q1xGrRCGdTEjd4

代码的重要部分:

static void pmrVector(benchmark::State& state)
{
  constexpr size_t BUF_SIZE = 1000000000;
  std::pmr::pool_options options;
  options.max_blocks_per_chunk = 40;
  options.largest_required_pool_block = 640;
    
  char* buffer = new char[BUF_SIZE];
  std::pmr::monotonic_buffer_resource pool{buffer, BUF_SIZE};
  std::pmr::unsynchronized_pool_resource mem (options,&pool);
  for (auto _ : state) 
  {
    {
      std::pmr::vector<char> vec{ &mem };
      for(int i = 0; i != 100000000; ++i)
      {
            
            vec.emplace_back('a');
            benchmark::DoNotOptimize(vec);
            
      }
    }
    mem.release();
    pool.release();
  }
  delete[] buffer;
}