Boost Intersocess支持共享过程之间包含指针的对象吗？

Question

我希望在Linux上共享包含内部指针的对象。

类似于？

BOOST.INTERPROCESS是否支持这一点？

除非每个过程都是以某种方式能够将内存映射到同一位置。

Boost的答案是什么？

Answer 1

如果共享地址空间，则可以安全地将这种分配器用于完整的结构

您要混合的“共享地址空间”和“地址映射在同一地址”的完整结构。因为如果没有地址空间共享，也不会出现存储原始指针的问题。

重要的是使用 boost :: intercess :: offset_ptr＆lt＆lt; t＆gt; 之类的精美指针。解释分配器使用 offset_ptr＆lt; t＆gt; 。

这就是为什么您需要使用支持花式指针的容器实现。

---

你很近。做您素描的规范方法：

>

#include <boost/container/string.hpp>
#include <boost/container/vector.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/managed_mapped_file.hpp>
#include <string>
namespace bip = boost::interprocess;

namespace Shared {
#ifdef COLIRU
    using Segment = bip::managed_mapped_file;
#else
    using Segment = bip::managed_shared_memory;
#endif
    using Mgr     = Segment::segment_manager;

    template <typename T> using Alloc  = bip::allocator<T, Mgr>;
    template <typename T> using Vector = std::vector<T, Alloc<T>>;

    using String = boost::container::basic_string< //
        char, std::char_traits<char>, Alloc<char>>;

    struct Bar {
        using allocator_type = Alloc<char>;
        String first_name, last_name;

        template <typename Alloc> Bar(std::string_view first_name, std::string_view last_name, Alloc alloc) : 
            first_name(first_name, alloc), last_name(last_name, alloc) {}
    };

    struct Snafu {
        std::array<int, 5> no_problem;
    };

    struct Foo {
        Vector<Bar>   bars;
        Vector<Snafu> snafus;

        template <typename Alloc> //
        Foo(Alloc alloc) : bars(alloc)
                         , snafus(alloc) {}
    };
}

#include <iostream>
static inline std::ostream& operator<<(std::ostream& os, Shared::Foo const& foo) {
    os << "Foo\n================\nBars:\n";
    for (auto& [f, l] : foo.bars)
        os << " - " << f << ", " << l << "\n";

    os << "nafus:";
    for (auto& s : foo.snafus) {
        os << "\n - ";
        for (auto el : s.no_problem)
            os << " " << el;
    }
    return os << "\n";
}


int main() { Shared::Segment msm(bip::open_or_create, "my_shared_mem", 10ull << 10);

    Shared::Foo& foo = *msm.find_or_construct<Shared::Foo>("the_foo") //
                        (msm.get_segment_manager()); // constructor arguments

    foo.bars.emplace_back("John", "Doe", msm.get_segment_manager());
    foo.bars.emplace_back("Jane", "Deer", msm.get_segment_manager());
    foo.bars.emplace_back("Igor", "Stravinsky", msm.get_segment_manager());
    foo.bars.emplace_back("Rimsky", "Korsakov", msm.get_segment_manager());

    foo.snafus.push_back({1, 2, 3});
    foo.snafus.push_back({2, 3, 4});
    foo.snafus.push_back({3, 4, 5, 6, 7});

    std::cout << foo << "\n";
}

输出第一次运行：

Foo
================
Bars:
 - John, Doe
 - Jane, Deer
 - Igor, Stravinsky
 - Rimsky, Korsakov
nafus:
 -  1 2 3 0 0
 -  2 3 4 0 0
 -  3 4 5 6 7

输出第二运行：

Foo
================
Bars:
 - John, Doe
 - Jane, Deer
 - Igor, Stravinsky
 - Rimsky, Korsakov
 - John, Doe
 - Jane, Deer
 - Igor, Stravinsky
 - Rimsky, Korsakov
nafus:
 -  1 2 3 0 0
 -  2 3 4 0 0
 -  3 4 5 6 7
 -  1 2 3 0 0
 -  2 3 4 0 0
 -  3 4 5 6 7

一如既往的奖金

，我不能对 scoped_allocator_adaptor ，这是切片半导体以来最好的东西：

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

现在，wherewherewherewhere awhere use_allocator 协议被用了，您会得到魔术分配的传播：

>

#include <boost/container/scoped_allocator.hpp>
#include <boost/container/string.hpp>
#include <boost/container/vector.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <string>
namespace bip = boost::interprocess;

namespace Shared {
#ifdef COLIRU
    using Segment = bip::managed_mapped_file;
#else
    using Segment = bip::managed_shared_memory;
#endif
    using Mgr     = Segment::segment_manager;

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

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

    using String = boost::container::basic_string< //
        char, std::char_traits<char>, Alloc<char>>;

    struct Bar {
        using allocator_type = Alloc<char>;
        String first_name, last_name;

        template <typename Alloc>
        Bar(std::allocator_arg_t, Alloc alloc) : first_name(alloc)
                                               , last_name(alloc) {}

        template <typename Alloc>
        Bar(Alloc&& alloc) : first_name(alloc)
                           , last_name(alloc) {}

        Bar(Bar const&) = default;
        template <typename Alloc>
        Bar(Bar const& rhs, Alloc alloc) : first_name(rhs.first_name, alloc), last_name(rhs.last_name, alloc) {}

        Bar& operator=(Bar const&) = default;

        template <typename Alloc> Bar(std::string_view first_name, std::string_view last_name, Alloc alloc) : 
            first_name(first_name, alloc), last_name(last_name, alloc) {}
    };

    struct Snafu {
        std::array<int, 5> no_problem;
    };

    struct Foo {
        Vector<Bar>   bars;
        Vector<Snafu> snafus;

        template <typename Alloc> //
        Foo(Alloc alloc) : bars(alloc)
                         , snafus(alloc) {}
    };
}

#include <iostream>
static inline std::ostream& operator<<(std::ostream& os, Shared::Foo const& foo) {
    os << "Foo\n================\nBars:\n";
    for (auto& [f, l] : foo.bars)
        os << " - " << f << ", " << l << "\n";

    os << "Snafus:";
    for (auto& s : foo.snafus) {
        os << "\n - ";
        for (auto el : s.no_problem)
            os << " " << el;
    }
    return os << "\n";
}


int main() { Shared::Segment msm(bip::open_or_create, "my_shared_mem", 10ull << 10);
    Shared::Foo& foo = *msm.find_or_construct<Shared::Foo>("the_foo") //
                        (msm.get_segment_manager()); // constructor arguments

    foo.bars.emplace_back("John", "Doe");
    foo.bars.emplace_back("Jane", "Deer");
    foo.bars.emplace_back("Igor", "Stravinsky");
    foo.bars.emplace_back("Rimsky", "Korsakov");

    foo.snafus.push_back({1, 2, 3});
    foo.snafus.push_back({2, 3, 4});
    foo.snafus.push_back({3, 4, 5, 6, 7});

    std::cout << foo << "\n";
}

输出相同

Answer 2

根据文档的答案是 no 。

在映射区域构造对象时的限制

抵消指针而不是原始指针
禁止参考
虚拟性禁止
小心静态类成员

当两个过程创建一个同一映射对象的映射区域时，
两个过程可以传达写作和读取该记忆。一个
进程可以在该内存中构造C ++对象，以便第二个
过程可以使用它。 但是，多个共享的映射区域
过程，无法容纳任何C ++对象，因为并非每个类都准备好
要成为一个过程共享的对象，特别是如果映射的区域为
在每个过程中映射在不同的地址中。

在每个过程中都

Boost确实提供了替代解决方案。
有几块魔术可以使这项工作：

• 偏移指针
• 告诉模板类型（例如容器）使用偏移指针，而不是通过分配器通过层叠来级联的指示器
• ，将此指令级联到模板类型上自动

提升，可自动提供使用智能偏移指针的容器（<

https://stackoverflow.com/a/a/7159729/1569204 有一个清晰的解释（不是特定的）：

template<class T> class offset_ptr {
    size_t offset; public:
    T* operator->() { return reinterpret_cast<T*>(reinterpret_cast<char*>(this)+offset); } };

这很聪明。我不确定为什么这尚未将其纳入ISO标准（也许它已经是无知的）。

请参阅 https://en.cppreference.com/w/nemed_req/nemed_req/allemed_req/allagreq/allalocator. #Fancy_Pointers

当成员类型指针不是原始指针类型时，通常是
称为“花哨的指针”。这样的指针被介绍给
支持分段的内存体系结构，今天用于访问
在地址空间中分配的对象，与同质不同
原始指针访问的虚拟地址空间。一个例子
花式指针是映射独立的指针
BOOST :: interpocess :: offset_ptr，这使得分配成为可能
基于节点的数据结构，例如std ::设置在共享存储器中和
内存映射的文件在每个过程中的不同地址中映射。
花哨的指针可以独立于分配者使用
通过类模板std :: pointer_traits向他们提供（因为
C ++ 11）。函数std :: to_address可用于获得RAW
从花式指针的指针。 （由于C ++ 20）

使用精美的指针和自定义大小/不同类型
有条件地支持标准性LIBARY。实施可能
需要该会员类型指针，const_pointer，size_type和
差异_type是value_type*，const value_type*，std :: size_t和
std :: ptrdiff_t。

这里有一个很好的解释：

• https://www.boost.org/doc/libs/1_64_0/doc/html/interprocess/allocators_containers.html#interprocess.allocators_containers.containers_explained.stl_container_requirements

The boost version of the containers uses the pointer type由分配器指定。
这就是为什么 sallocator_traits 包括一个指针类型。
从理论上讲，STL实现（C ++ 11）应使用它，而不是假设原始指针。提升容器确保完成此操作。因此，增强分配器不仅返回Offset_ptr指针，而且还告知容器模板也应该使用它们。

另一个魔术是获取模板使用结构包含它的分配器的标准方法。
参见什么是”在C ++中使用分配器“和“范围分配器”构建

至少C ++ 11以来，这种魔术一直存在于C ++中。