Boost共享内存/内存映射文件构建容器的封装 可作为对象序列化使用

最新推荐文章于 2024-04-06 21:12:05 发布
最新推荐文章于 2024-04-06 21:12:05 发布
阅读量1.4k 收藏 7
点赞数 2
分类专栏： boost

转自：https://anonymalias.github.io/2016/01/14/boost_ipc_pack/

Boost共享内存/内存映射文件构建容器的封装

文章目录

  1. 1.首先是对boost ipc的托管内存段进行封装，如下：
  2. 2.其次是对要构建的各个容器进行封装，这里举例map的封装：
  3. 3.在托管内存段上进行容器的构建如下：

本人github主站：https://anonymalias.github.io
本人csdn主站：http://blog.csdn.net/anonymalias

Boost Interprocess组件提供了通过了托管内存段(managed_mapped_file & managed_shared_memory)在共享内存和内存映射文件上进行复杂数据结构构建的功能。

通过boost.ipc构造简单的POD纯数据结构, 非常的简单

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
#include <cstdio>
#include <boost/interprocess/managed_mapped_file.hpp>

namespace bipc = ::boost::interprocess;
typedef bipc::managed_mapped_file managed_mapped_file_t;
typedef bipc::managed_mapped_file::segment_manager mapped_segment_manager_t;

struct Msg 
{
    uint32_t id; 
    char name[128];
    uint32_t age;
};

int main()
{
    managed_mapped_file_t obj_mapped_file(bipc::open_or_create, "./msg_map.mmap", 1024*1024);
    Msg * p_msg = obj_mapped_file.find_or_construct<Msg>("msg_map")();
    if(NULL == p_msg)
    {   
        std::cerr<<"construct msg failed"<<std::endl;
        return -1; 
    }   

    std::cout<<p_msg->id<<std::endl;
    std::cout<<p_msg->name<<std::endl;
    std::cout<<p_msg->age<<std::endl;

    p_msg->id = p_msg->id + 1;
    strcpy(p_msg->name, "hello world!");
    p_msg->age = p_msg->age + 1;

    return 0;
}

 

在项目过程中，更多的时候是需要在共享内存/内存映射文件上构建复杂的容器。我们知道一般

  • 容器的分配器：容器的构造是直接在进程的地址空间(堆)上进行的，容器的分配器allocator都是默认构造的，所以其分配器可认为是无状态的（stateless）。
  • boost.ipc的分配器：需要从具体的系统内核内存片段上进行内存的分配，而不是进程的内存资源，所以boost.ipc的分配器是有状态的(stateful), 言外之意，需要告知boost.ipc的分配器，在哪里进行内存分配，必须传入共享内存，或是内存映射文件。

所以要在boost.ipc上构造容器，需要将boost.ipc的分配器作为容器的allocator传入容器，让容器知道在ipc上进行内存分配和对象构造。Boost ipc的allocator内的get_segment_manager()可以返回allocator构造时传入的内存片段管理器。(注意：托管内存段(managed_mapped_file & managed_shared_memory)的内存片段管理器segment_manager 本质是一个allocator，在文章http://blog.csdn.net/anonymalias/article/details/50496563有详解)。

所以现在在boost.ipc上构建一个map，需要有两步操作(这里已mapped file举例)：

  • 构建mapped_file对象。
  • 通过mapped_file对象，构建map，在构建map的时候需要传入mapped_file的分配器。

代码如下：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#include <iostream>

#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/allocators/node_allocator.hpp>

#include <boost/container/string.hpp>

namespace bipc = ::boost::interprocess;
typedef bipc::managed_mapped_file managed_mapped_file_t;
typedef bipc::managed_mapped_file::segment_manager mapped_segment_manager_t;

struct Msg 
{
    uint32_t id; 
    bipc::string name;
    uint32_t age;
};

typedef std::pair<const uint32_t, Msg> pair_t;
typedef bipc::node_allocator<pair_t, mapped_segment_manager_t> allocator_t;
typedef std::less<uint32_t> less_t;

typedef bipc::map<uint32_t, Msg, less_t, allocator_t> msg_map_t;
typedef msg_map_t::iterator map_iter_t;

int main()
{
    managed_mapped_file_t obj_mapped_file(bipc::open_or_create, "./msg_map_boost.mmap", 1024*1024);
    msg_map_t *p_msg_map = obj_mapped_file.find_or_construct<msg_map_t>("msg_map")(less_t(), \
            obj_mapped_file.get_segment_manager());
    if(NULL == p_msg_map)
    {   
        std::cerr<<"construct msg_map failed"<<std::endl;
        return -1; 
    }   

    for(int i = 0; i < 10; ++i)
    {   
        map_iter_t itr = p_msg_map->find(i);
        if(itr == p_msg_map->end())
        {   
            std::cout<<"not find:"<<i<<" insert:"<<i<<std::endl;
            Msg msg = {i, "alias", 100+i};
            p_msg_map->insert(std::pair<uint32_t, Msg>(i, msg));
        }   
        else
        {   
            std::cout<<"find:"<<i<<" data:"<<itr->second.name<<" "<<\
                itr->second.age<<std::endl;
        }   
    }   
    return 0;
}

 

为了代码的可读性，需要定义一堆的typedef来指定待构建map的allocator的构造传参是一个boost ipc的segment_manager。当map的value不是POD，而是嵌套其他容器是，你将会看到这样的定义：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

namespace bipc = ::boost::interprocess;
typedef bipc::managed_mapped_file managed_mapped_file_t;
typedef bipc::managed_mapped_file::segment_manager mapped_segment_manager_t;

typedef bipc::node_allocator<float, mapped_segment_manager_t> vec_allocator_t;
typedef boost::container::vector<float, vec_allocator_t> vector_t;

struct Msg 
{
    Msg(const vec_allocator_t &vec_alloc) : score(vec_alloc){}

    uint32_t id; 
    bipc::string name;
    uint32_t age;
    vector_t score;
};

typedef std::pair<const uint32_t, Msg> pair_t;
typedef bipc::node_allocator<pair_t, mapped_segment_manager_t> allocator_t;
typedef std::less<uint32_t> less_t;

typedef bipc::map<uint32_t, Msg, less_t, allocator_t> msg_map_t;
typedef msg_map_t::iterator map_iter_t;

 

程序员的天性(C++程序员。。。)， tigerlan我的导师为了不愿意造轮子，对在boost ipc上进行容器构造的逻辑进行了封装：那我写这篇文章还有毛意义，又不是我造的轮子，其实使用过程中，还是发现一些问题，算是对自己的一个提升吧，写这篇文章的本意也是想让自己记录一下过程中遇到的问题和细节，已经和大家分享的过程。

1.首先是对boost ipc的托管内存段进行封装，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <functional>
#include <utility>
#include <string>

typedef boost::interprocess::managed_mapped_file mapped_file_t;
typedef boost::interprocess::managed_shared_memory shared_memory_t;

template <typename segment>
class Segment
{
public:
    typedef segment segment_t ;
    typedef typename segment_t::segment_manager segment_manager_t ;
public:
    Segment(const char * name, size_t size):
        m_name(name),m_size(size),
        m_segment(boost::interprocess::open_or_create, m_name.c_str(), m_size )
    { }

    segment_t & operator () ()
    {
        return m_segment;
    }
    /*
    ...省略
    */
private:
    std::string m_name;
    size_t m_size;
    segment_t m_segment;
};

typedef Segment< mapped_file_t > MapedFile;
typedef Segment< shared_memory_t > SharedMemory;

2.其次是对要构建的各个容器进行封装，这里举例map的封装：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#include <boost/interprocess/allocators/node_allocator.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/offset_ptr.hpp>
#include <functional>
#include <utility>

#include "segment.hpp"

namespace bip = boost::interprocess;

template <typename key_t,typename data_t, typename segment_t>
class SegmentMap
{
    typedef typename segment_t::segment_manager_t segment_manager_t;
    typedef typename std::pair<const key_t, data_t> pair_t;
    typedef typename std::less<key_t> less_t;
    typedef typename bip::node_allocator <pair_t , segment_manager_t> allocator_t;

public:
    typedef typename bip::map<key_t, data_t, less_t ,allocator_t> map_t;
    typedef typename map_t::iterator iterator;

public:
    SegmentMap(const char * name, segment_t & segment ) :
        m_segment( segment ),
        m_allocator( m_segment().get_segment_manager() )
    {
        m_segment_map = m_segment().template find_or_construct<map_t>
        (name) (less_t(),m_allocator);

        assert(m_segment_map != NULL);
    }

    SegmentMap(segment_t & segment) :
        m_segment( segment ),
        m_allocator( m_segment().get_segment_manager() )
    {
        m_segment_map = m_segment().template find_or_construct< map_t >
            ( bip::anonymous_instance ) (less_t(), m_allocator);
        assert(m_segment_map != NULL);
    }

    ~SegmentMap(){};

    map_t & operator () ()
    {
        return *m_segment_map;
    }

    /*
    ...省略
    */

private:
    segment_t & m_segment;
    allocator_t m_allocator;
    bip::offset_ptr<map_t> m_segment_map;
};

3.在托管内存段上进行容器的构建如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include "iostream"

#include "segment.hpp"
#include "segment_map.hpp"
#include "segment_list.hpp"

typedef MapedFile _Memory;
_Memory * g_memory = NULL;

struct Company
{
    typedef SegmentList<uint32_t, _Memory> leader_list_t;
    typedef SegmentList<uint32_t, _Memory> colleague_list_t;
    leader_list_t leader_list;
    colleague_list_t colleague_list;

    Company() : leader_list(*g_memory), colleague_list(*g_memory){}
};

typedef SegmentMap<uint32_t, Company, _Memory> company_map_t;

int main()
{
    g_memory = new _Memory("test.mmap", 1024 * 1024);

    company_map_t * p_company_map = new company_map_t("test2", *g_memory);
    company_map_t::iterator itr;

    for(int i = 0; i < 10; ++i)
    {   
        itr = (*p_company_map)().find(i);
        if(itr == (*p_company_map)().end())
        {   
            std::cout<<"not find:"<<i;

            Company &obj = (*p_company_map)[i];
            obj.leader_list().push_back(i + 100);

            std::cout<<"insert:"<<i + 100<<std::endl;
        }   
        else
        {   
            std::cout<<"find:"<<i;
            for(Company::leader_list_t::iterator list_itr = itr->second.leader_list().begin(); 
                    list_itr != itr->second.leader_list().end(); ++list_itr)
            {   
                std::cout<<" value:"<<*list_itr;
            }   

            std::cout<<std::endl;
        }   
    }   
}

可以看出利用封装过后的Segment和SegmentList, SegmentMap,进行容器的构建是很方便的一件事情，需要注意的是map的value：struct Company的构造需要传入boost ipc的分配器，以便内部的list对象进行构造。所已需要Company的默认构造函数，无参，且参数初始化列表传入全局的已初始化的托管内存段对象，否则不能map的[]操作符。

hlday6
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Boost：多进程间在共享内存中创建对象
风静如云的博客
12-01 249
介绍了如何使用共享内存，但是这种方式，只能在共享内存中保存比较简单的数据类型，而C++中经常会使用类，类对象通常是通过构造函数进行创建的，有没有办法在共享内存中保存类对象呢。destroy成员函数用于删除共享内存中的对象，destroy_ptr通过construct时返回的指针进行删除。(v.begin())：通过迭代器进行构造，每个对象通过*it++进行构造，因此会接收到不同的参数。注：这种方式传递给构造函数的参数是一致的，每个对象都通过88进行构造。("A_arrayIt")表示数组对象的名字。
【Boost C++ 库】托管共享内存详解
08-23 1068
为此，Boost.Interprocess 提供了在boost/interprocess/allocators/allocator.hpp中定义的boost::interprocess::allocator类. 使用这个类，可以创建一个分配器，它在内部使用托管共享内存的段管理器。但是，只有当访问托管共享内存的所有其他进程也使用atomic_func(). 如果另一个进程有一个指向托管共享内存中的对象的指针，它可以使用它的指针访问和修改这个对象。要访问托管共享内存中的特定对象，可以使用find()成员函数。
Boost:managed_mapped_file及C++内存分配和对象构造分析
anonymalias的专栏
01-11 7584
Boost的提供了一套ipc的接口，内存映射文件将文件的内容映射到进程的地址空间。#include <boost/interprocess/file_mapping.hpp>原生的file_mapping接口提供了创建一个内存映射文件，然后通过mapped_region进行进程地址空间的映射，获取映射到进程空间的地址，并在此地址进行对象的构造和操作。由于直接在映射的地址进行复杂数据结构的构造很复杂的
c++中用boost实现共享内存创建map容器
开源的才是世界的
02-26 6862
网上有很多创建通过boost共享内存或者在内存中放置vector的例子，但是没找到有创建嵌套map和读取的例子，于是把自己以前写的例子贴出来，没用过的可以少走弯路，自己以后也方便查阅。#include #include #include #include #include using namespace boost::interprocess; using std::cout; usi
py_boost_shmem:在boost之间映射共享内存的示例
05-26
py_boost_shmem 在boost :: interprocess和Python的mmap之间映射共享内存的示例。 我在将python（使用mmap模块）中的共享内存连接到使用boost :: interprocess创建的C ++中的共享内存时遇到问题。 我开始工作了，想在将来为自己以及其他可能遇到此问题的其他人发布解决方案。 此示例与一起编写
Boost IPC共享内存的使用总结
dbdxnuliba的博客
10-11 2858
Boost IPC共享内存的使用总结 https://my.oschina.net/lday/blog/724458 http://zh.highscore.de/cpp/boost/interprocesscommunication.html 共享内存，是进程间数据传输的方式之一。数据发送方将数据放入共享内存中，数据接收方则从共享内存中将数据读出，进而完成整个数据的传输。在Linux平台...
boost共享内存使用（3）managed_shared_memory共享内存分配器
二进制君
04-06 1290
Boost.Interprocess提供了一些基本的类来创建共享内存对象和文件映射，并将这些可映射的类映射到进程的地址空间中。然而，管理这些内存段对于非平凡的任务来说并不容易。一个映射区域是一个固定长度的内存缓冲区，动态创建和销毁任何类型的对象需要大量的工作，因为这将需要编写一个内存管理算法来分配该段的部分。许多情况下，我们还希望将名称与在共享内存中创建的对象关联起来，以便所有进程都可以使用名称找到该对象。
boost共享内存：managed_shared_memory用法示例
哦，原来你也在这里。
07-23 3523
#include <iostream> #include <thread> #include <chrono> #include <boost/smart_ptr.hpp> #include <boost/make_shared.hpp> #include <boost/interprocess/managed_shared_memory.hpp> //#include <boost/interprocess/managed_.
VS、VC++实现对象序列化保存到sqlite表blob类型字段中，包含blob字段的读取和保存，
04-04
首先，对象序列化通常是通过自定义序列化函数或使用库（如Boost.Serialization或C++标准库中的`std:: stringstream`）来完成的。在这个场景中，我们可能需要为每个要序列化的类定义`serialize`函数，该函数将对象的...
BeastHttp：提供用于使用Boost.Beast创建RESTful服务的辅助工具。
02-03
4. JSON序列化与反序列化：RESTful服务通常与JSON数据交换，BeastHttp可能包含与Boost.JSON或其他库集成的组件，以简化数据的转换。 5. 异步编程模型：为了充分利用多核CPU，BeastHttp可能支持非阻塞I/O，允许并发...
boost_1_63_0-src.zip
09-23
此外，Boost.Test库为C++测试提供了强大的支持，而Boost.Serialization库则实现了对象序列化和反序列化，方便数据持久化和跨进程通信。Boost.Signals2库则简化了事件驱动编程，使得组件间的通信更为便捷。 总的来说...
Boost C++ 库 简介（中文）
07-15
9. **序列化**（Serialization）：Boost.Serialization库提供了将对象的状态序列化到文件或内存中的能力，便于持久化和传输。 10. **数学与统计**（Math and Statistics）：Boost.Math库包含了各种数学函数和统计学...
boost1.3中文帮助(chm)与安装说明
03-17
9. **序列化库**：`serialization`库能够将对象序列化到文件或内存中，便于持久化存储和传输。 10. **正则表达式库**：`regex`库提供了C++接口的Perl风格正则表达式。 接下来是关于在Windows下编译和配置Boost的...
boost共享内存使用（1）认识shared_memory_object和mapped_region
二进制君
04-06 1001
shared_memory_object类是boost库中用于创建和管理共享内存对象的类。它提供了一种在多个进程之间共享数据的方法，允许这些进程共享同一块内存区域。主要作用包括：创建共享内存对象：可以使用shared_memory_object类来创建一个新的共享内存对象。通过指定名称、大小和访问权限等参数，可以创建一个新的共享内存区域。打开现有的共享内存对象：如果共享内存对象已经存在，可以使用shared_memory_object类来打开它。通过指定名称和访问权限等参数，可以打开现有的共享内存区域。
基于boost的共享内存系列-map
ljp1919的专栏
07-01 2889
背景：将自定义的map类型以共享内存的方式进行保留，以进行进程间通信。方案设计：map是容器的一种，而如果其key或者value也是容器的话，则该问题可以视为容器中的容器问题。如果在容器中又包含了容器的话，那么每个容器都是需要一个allocator。为避免使用数个复杂定义的分配器，我们可以使用空分配器提供的类型擦除和隐式转换空分配器至其他类型的能力。 实现过程： 创建共享内存片段managed_
Boost.Interprocess使用手册翻译之七：托管内存片段（Managed Memory Segments）
热门推荐
great3779的专栏
02-09 1万+
七．            托管内存片段 使进程间数据通信变容易 托管共享内存 托管映射文件 托管内存片段的特性 托管内存片段的高级特性 托管堆内存和托管外部缓冲区 使进程间数据通信变容易 介绍 声明托管内存片段类 介绍 正如我们所看到的，Boost.Interprocess提供一些基本的类来构建共享内存对象和文
boost Shared Memory
weixin_30293135的博客
07-31 338
Shared Memory Shared memory is typically the fastest form of interprocess communicatioin. It provides a memory area that is shared between processes. One process can write data to the area and ...
boost C++知识点（七）
qq_23350817的博客
10-26 1546
6.3. 托管共享内存 上一节介绍了用来创建和管理共享的 boost::interprocess::shared_memory_object 类。 实际上，由于这个类需要按单个字节的方式读写共享内存，所以这个类几乎不用。 概念上来讲，C++改善了类对象的创建并隐藏了它们存储在内存中哪里，是怎们存储的这些细节。 Boost.Interprocess 提供了一个名为“托管共享内存”的概念，通过定义在 ...
DBO-CNN-BiLSTM-Attention蜣螂算法优化多变量时间序列预测，含优化前后对比（Matlab完整源码和数据）
最新发布
08-17
1.Matlab实现DBO蜣螂算法优化CNN-BiLSTM-Attention多变量时间序列预测，含优化前后对比（Matlab完整源码和数据）优化学习率，神经元个数，注意力机制的键值, 正则化参数。 2.输出MAE 、 MAPE、MSE、RMSE、R2多指标评价，运行环境Matlab2023及以上。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：机器学习之心，博客专家认证，机器学习领域创作者，2023博客之星TOP50，主做机器学习和深度学习时序、回归、分类、聚类和降维等程序设计和案例分析，文章底部有博主联系方式。从事Matlab、Python算法仿真工作8年，更多仿真源码、数据集定制私信.
共享内存(内存映射文件)封装类以及使用实例_vc内存文件类
09-03
共享内存是一种用于多个进程之间进行数据交换的机制。共享内存封装类是为了方便开发者使用共享内存而设计的类。它封装了底层的共享内存操作，提供了一些简洁易用的接口供开发者调用。 在C++中，可以使用第三方库例如Boost库或者Qt库提供的共享内存封装类，也可以自己编写封装类。无论是使用第三方库还是自己编写封装类，共享内存封装类通常会提供以下功能： 1. 创建或打开共享内存：封装类提供了一些方法用于创建或打开已存在的共享内存区域。 2. 写入和读取数据：封装类提供了方法用于往共享内存中写入数据或从共享内存中读取数据。 3. 同步机制：封装类通常提供了一些同步机制，例如互斥锁或条件变量，来确保多个进程之间对共享内存的读写操作是安全的。 一个使用共享内存封装类的实例是_vc内存文件类。_vc内存文件类是属于Qt库中的一部分，用于在不同的进程之间共享数据。它提供了一些方法来创建、打开、写入和读取共享内存中的数据。 使用_vc内存文件类时，首先需要创建一个_vc内存文件对象，然后可以调用其方法来创建或打开已存在的共享内存区域。创建或打开成功后，就可以使用对象的方法来进行数据的写入和读取操作。 例如，可以调用_vc内存文件对象的writeData()方法来写入数据，该方法会将数据写入共享内存中的指定位置；而调用readData()方法可以从共享内存中读取数据。 在使用_vc内存文件类时，还可以利用其提供的同步机制，例如setLock()方法用于设置互斥锁，以确保多个进程之间对共享内存的操作是互斥的，同时可以使用条件变量来进行进程间的通信。 总之，共享内存封装类和_vc内存文件类是用于方便开发者使用共享内存的工具，通过封装底层操作，使得开发者可以更方便地进行数据共享和交换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值