Boost 分配器的向量大小不正确

Question

以下程序在内存映射文件的空间内为c（C 类型的对象）分配内存。向c 中包含的向量添加单个字符会将向量报告的大小从 0 更改为 18446744073709551520。

#include <iostream>
#include <new>
#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/offset_ptr.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/operations.hpp>

using namespace boost::interprocess;

class C;

typedef managed_mapped_file::segment_manager SegmentManager;
typedef allocator<void, SegmentManager> VoidAllocator;
typedef allocator<char, SegmentManager> CharAllocator;
typedef allocator<C, SegmentManager> CAllocator;
typedef offset_ptr<C> CPtr;

class C {
  public:
    std::vector<char, CharAllocator> data;

    C(const VoidAllocator &voidAlloc) : data(voidAlloc) {}

    void add_char() {
      std::cout << data.size() << std::endl;
      data.push_back('x');
      std::cout << data.size() << std::endl;
    }
};

int main(int argc, char *argv[]) {
  boost::filesystem::remove_all("file");
  managed_mapped_file segment(create_only, "file", 100000);

  VoidAllocator allocator_instance(segment.get_segment_manager());
  CAllocator alloc_c(allocator_instance);
  CPtr c = alloc_c.allocate_one();
  *c = C(allocator_instance);
  c->add_char();

  return 0;
}

当c在堆栈上分配而不是动态分配时，不会出现该问题。

C c(allocator_instance);
c.add_char();

我在 Debian GNU/Linux 上使用 Boost 1.62 和 g++ 6.3.0-18 使用以下命令编译代码。

g++ -Wall -pthread  -lboost_system -lboost_filesystem t.cpp -o t

Answer 1

分配器返回原始的、未初始化的内存。

通过它间接指向C 类型的对象是Undefined Behaviour。

您当然可以使用placement-new 实际完成繁重的工作：

CPtr c = alloc_c.allocate_one();
new (&*c) C(allocator_instance);

请注意，同样，对于非 POD（或者实际上，非平凡可破坏的类型），您还必须记住在适当的时间调用析构函数：

CPtr c = alloc_c.allocate_one();

new (&*c) C(allocator_instance);
*c = C(allocator_instance);

c->add_char();

c->~C();
alloc_c.deallocate_one(c);

但正如您已经指出的那样，高级方法避免了新/删除并使用段管理器：

CPtr c = segment.construct<C>("Name") (allocator_instance); 

演示

使用

• find_or_construct 因此可以按名称检索共享对象（如果您不希望这样做，请使用 anonymous 或 unique 实例；另请注意，您可以通过相同的名称实例化多个实例）

• 使用allocator_type 有助于使用范围分配器适配器（想想：vector<C>）

• 参数化的C 使其易于与标准分配器和共享内存分配器一起使用

• 使用段管理器指针和分配器实例的隐式转换

• 隐藏实现细节offset_ptr（90% 的时间你不需要知道）

Live On Coliru

#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <iostream>

namespace bip = boost::interprocess;

namespace Shared {
    using Segment         = bip::managed_mapped_file;
    using Manager         = Segment::segment_manager;
    template <typename T = void>
        using Alloc       = bip::allocator<T, Manager>;
    template <typename T>
        using Vector      = bip::vector<T, Alloc<T> >;

    template <typename Alloc = std::allocator<void> >
    struct C {
        using allocator_type = Alloc;
        bip::vector<char, typename Alloc::template rebind<char>::other> data;

        C(Alloc alloc = {}) : data(alloc) {}

        void add_char() {
            std::cout << data.size() << std::endl;
            data.push_back('x');
            std::cout << data.size() << std::endl;
        }
    };
}

int main() {
    std::remove("file");
    Shared::Segment mmf(bip::create_only, "file", 1000000);

    using Alloc = Shared::Alloc<>;
    using C = Shared::C<Alloc>;

    auto* c = mmf.find_or_construct<C>("byname")(mmf.get_segment_manager());

    c->add_char();

    //mmf.destroy_ptr(c);
}

打印

0
1

Answer 2

似乎将构造的对象从默认内存池移动到段一会以某种方式混淆向量的实现。使用construct方法直接在段内存池中构造对象即可解决问题。

CPtr c = segment.construct<C>(anonymous_instance) (allocator_instance);