有没有办法为向量采用内存资源？

Question

我已经开始在我的项目中使用 pmr::allocators，并且我已经看到使用它们带来了很多性能提升和优势。我使用的分配器与我在下面的简单示例中展示的非常相似：

#include <array>
#include <boost/container/flat_map.hpp>
#include <cassert>
#include <iostream>
#include <memory_resource>
#include <string>
#include <vector>

struct MessageBody {
  using map_t = boost::container::flat_map<
      char, char, std::less<char>,
      std::pmr::polymorphic_allocator<std::pair<char, char>>>;

  using vector_t = std::vector<char, std::pmr::polymorphic_allocator<char>>;

  MessageBody(std::pmr::memory_resource& mem_v,
              std::pmr::memory_resource& mem_m)
      : vec_(0, &mem_v), map_(&mem_m) {}

  vector_t vec_;
  map_t map_;
};

int main() {
  std::array<char, 1000> buffer;
  buffer.fill('\0');
  std::pmr::monotonic_buffer_resource vec_mem(buffer.data(), 500,
                                              std::pmr::null_memory_resource());
  std::pmr::monotonic_buffer_resource map_mem(buffer.data() + 500, 500,
                                              std::pmr::null_memory_resource());
  {
    MessageBody message(vec_mem, map_mem);
    message.vec_.push_back('1');
    assert(message.vec_.size() == 1);
  }

  {
    MessageBody message(vec_mem, map_mem);
    assert(message.vec_.size() == 1);   /// I want to adopt the previous class for a new class.
  }
}

我的问题是，是否有任何方法可以将 memory_resources 用于另一个类，而无需在 vector 和 map 中重新填充整个数据。

我能想到的唯一方法（我知道这是一个糟糕的主意）是实现一个继承自 std::vector 的新类，该类有一个采用数据方法来设置 size在不修改缓冲区的情况下将向量内部的大小调整为先前使用的向量的大小。

这里是示例的godbolt链接。

https://godbolt.org/z/fcox5vTdE

Answer 1

你想要的不是采用内存资源——因为你可以并且做——而是也将向量本身存储在那里。

你可以，例如使用帮助器创建带有自定义删除器的 unique_ptr：

template <typename T>
inline static auto make_T(Mem& mem) {
    std::pmr::polymorphic_allocator<T> alloc(&mem);
    return std::unique_ptr{
        alloc.template new_object<T>(), // allocator is propagated
        [alloc](T* p) { alloc.delete_object(p); }};
}

当库对 C++20 的支持不完整时，需要做更多的工作，所以让我在Compiler Explorer上的现场演示中展示这一点

但是，您无法使用 C++ 内存抽象机模型在同一内存上“复活”非平凡类型。

缓冲区中的活动对象 - 进入 Boost Interprocess

您真正想要的是在那里存储 /live objects/ 并从其他地方访问它们。

您可以使用共享内存分配器来执行此操作，例如来自 Boost Interprocess。你可以这样做

• 手动分配的缓冲区（类似于单调的内存资源）
• 托管共享内存段
• 托管映射文件

当然，在后一种情况下，持久性和多进程访问也有好处。

如果您不需要 IPC 或持久性，但喜欢托管分段功能，请使用 managed_external_buffer

使用托管外部缓冲区的演示

需要几个 typedef 来设置：

namespace Shared {
    using Mem = bip::managed_external_buffer;

    template <typename T>
    using Alloc = boost::container::scoped_allocator_adaptor<
        bip::allocator<T, Mem::segment_manager>>;

    template <typename T>
    using Vector = boost::container::vector<T, Alloc<T> >;

    template <typename K, typename V, typename Cmp = std::less<K>>
    using Map =
        boost::container::flat_map<K, V, std::less<K>, Alloc<std::pair<K, V>>>;
} // namespace Shared

请注意我如何使用 scoped_allocator_adaptor 来尽可能接近 PMR 根据uses_allocator<> 将容器分配器传播到元素类型的行为。

struct MessageBody
{
    using map_t = Shared::Map<char, char>;
    using vector_t = Shared::Vector<char>;

    template <typename Alloc>
    MessageBody(Alloc alloc) : vec_(alloc), map_(alloc)
    { }

    vector_t vec_;
    map_t    map_;
};

不再需要 unique_ptr，您的数据结构基本上就是您拥有的，但我们将所有内容都存储在一个内存资源中，因此整个东西可以“复活”为一个：

int main() {
  std::array<char, 1000> buffer;
  buffer.fill('\0');

  {
      Shared::Mem mem(bip::create_only, buffer.data(), buffer.size());

      auto& message = *mem.find_or_construct<MessageBody>("message")(
          mem.get_segment_manager());

      message.vec_.push_back('1');
      assert(message.vec_.size() == 1);
  }

  {
      Shared::Mem mem(bip::open_only, buffer.data(), buffer.size());

      auto& message = *mem.find_or_construct<MessageBody>("message")(
          mem.get_segment_manager());

      assert(message.vec_.size() == 1);
  }
  std::cout << "Bye" << "\n";
}

get_segment_manager() 调用返回一个指针，该指针用作Shared::Alloc<> 实例的初始化器。

现在它通过了断言：Live On Coliru

只是打印

Bye