[关闭]
@Pigmon 2019-01-02T16:59:05.000000Z 字数 14131 阅读 3548

boost::interprocess 共享内存

C++

0. 链接

https://theboostcpplibraries.com/boost.interprocess
https://www.boost.org/doc/libs/1_67_0/doc/html/interprocess.html

1. Makefile

  1. all:
  2.     g++ test.cpp -pthread -o test -lrt
  3. clean:
  4.     rm -r test

-lrt 必须在最后，否则link错误。原因不详。

2. Basic Shared Memory

TODO

3. Managed Shared Memory

3.1 存取一个整数

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <iostream>
  4. using namespace boost::interprocess;
  6. int main()
  7. {
  8.     // 先删除
  9.     bool ret = shared_memory_object::remove("My_SHM");
  10.     std::cout << std::boolalpha << ret << std::endl;
  12.     // 构造 managed shared memory 对象
  13.     managed_shared_memory managed_shm(open_or_create, "My_SHM", 1024);
  14.     int *i = managed_shm.construct<int>("My_Age")(109);
  15.     std::cout << *i << '\n';
  17.     // 按名字读取
  18.     std::pair<int *, std::size_t> p = managed_shm.find<int>("My_Age");
  19.     if (p.first)
  20.         std::cout << *p.first << ":" << p.second << std::endl;
  21. }

3.2 存取一个 Vector

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <iostream>
  5. using namespace boost::interprocess;
  7. typedef boost::interprocess::vector<int> IntVec;
  9. int main()
  10. {
  11.     int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  12.     IntVec vec(arr, arr + sizeof(arr) / sizeof(int));
  13.     // 先删除
  14.     shared_memory_object::remove("My_SHM_Array");
  15.     // 构建 managed shared memory
  16.     managed_shared_memory managed_shm(open_or_create, "My_SHM_Array", 1024);
  17.     // 将 vec 存储至 shared memory, 或者使用 find_or_construct
  18.     IntVec *vec_shm = managed_shm.construct<IntVec>("Numbers")(vec);
  19.     std::cout << (*vec_shm)[2] << '\n';
  21.     // 读取
  22.     std::pair<IntVec*, std::size_t> p = managed_shm.find<IntVec>("Numbers");
  23.     if (p.first)
  24.     {
  25.         std::cout << (*(p.first))[8] << '\n';
  26.         std::cout << p.second << '\n';
  27.     }
  28. }

3.3 捕获内存分配异常

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <iostream>
  4. using namespace boost::interprocess;
  6. int main()
  7. {
  8.     try
  9.     {
  10.         shared_memory_object::remove("My_SHM_Array");
  11.         managed_shared_memory managed_shm(open_or_create, "My_SHM_Array", 1024);
  12.         int *i = managed_shm.construct<int>("Numbers")[4096](99);
  13.     }
  14.     catch (boost::interprocess::bad_alloc &ex)
  15.     {
  16.         std::cerr << ex.what() << '\n';
  17.     }
  18. }

3.4 删除共享内存对象

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <iostream>
  4. using namespace boost::interprocess;
  6. int main()
  7. {
  8.     shared_memory_object::remove("My_SHM_Array");
  9.     managed_shared_memory managed_shm(open_or_create, "My_SHM_Array", 1024);
  10.     int *i = managed_shm.find_or_construct<int>("Numbers")(99);
  11.     std::cout << *i << '\n';
  12.     managed_shm.destroy<int>("Numbers");
  13.     std::pair<int *, std::size_t> p = managed_shm.find<int>("Numbers");
  14.     std::cout << p.first << '\n';
  15. }

3.5 存储 string

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/allocators/allocator.hpp>
  3. #include <boost/interprocess/containers/string.hpp>
  4. #include <iostream>
  6. using namespace boost::interprocess;
  8. int main()
  9. {
  10.     shared_memory_object::remove("My_SHM_String");
  11.     managed_shared_memory managed_shm(open_or_create, "My_SHM_String", 1024);
  13.     typedef allocator<char, managed_shared_memory::segment_manager> CharAllocator;
  14.     typedef basic_string<char, std::char_traits<char>, CharAllocator> AString;
  16.     AString *s = managed_shm.find_or_construct<AString>("MyString")("Hello!", managed_shm.get_segment_manager());
  18.     s->insert(5, ", world");
  19.     std::cout << *s << '\n';
  20. }

3.6 原子操作

需要在操作过程中起到类似加锁的功能，即在操作过程中不受其他进程干扰时使用。
其他进程必须也使用 atomic_func 来访问这个共享内存对象才能保证这个机制。

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <functional>
  3. #include <iostream>
  5. using namespace boost::interprocess;
  7. /// 原子操作本体
  8. void construct_objects(managed_shared_memory &managed_shm)
  9. {
  10.     managed_shm.construct<int>("A_Int_Number")(99);
  11.     managed_shm.construct<float>("A_Float_Number")(3.14);
  12. }
  14. int main()
  15. {
  16.     shared_memory_object::remove("My_SHM_Obj");
  17.     managed_shared_memory managed_shm(open_or_create, "My_SHM_Obj", 1024);
  19.     // 绑定 原子操作 和 managed_shared_memory对象
  20.     auto atomic_construct = std::bind(construct_objects, std::ref(managed_shm));
  21.     managed_shm.atomic_func(atomic_construct);
  23.     std::cout << *managed_shm.find<int>("A_Int_Number").first << '\n';
  24.     std::cout << *managed_shm.find<float>("A_Float_Number").first << '\n';
  25. }

3.7 在两个进程中用共享内存通信一个 Vector

Server:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <string>
  5. //#include <cstdlib> //std::system
  6. #include <iostream>
  8. using namespace boost::interprocess;
  10. //Define an STL compatible allocator of ints that allocates from the managed_shared_memory.
  11. //This allocator will allow placing containers in the segment
  12. typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator;
  13. typedef vector<int, ShmemAllocator> MyVector;
  15. int main(int argc, char *argv[])
  16. {
  17.     shared_memory_object::remove("MySharedMemory");
  19.     managed_shared_memory segment(create_only, "MySharedMemory", 65536);
  21.     //Initialize shared memory STL-compatible allocator
  22.     const ShmemAllocator alloc_inst(segment.get_segment_manager());
  23.     MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst);
  25.     for (int i = 0; i < 100; ++i)
  26.         myvector->push_back(i);
  28.     return 0;
  29. };

Client:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <string>
  5. #include <iostream>
  7. using namespace boost::interprocess;
  9. //Define an STL compatible allocator of ints that allocates from the managed_shared_memory.
  10. //This allocator will allow placing containers in the segment
  11. typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator;
  12. typedef vector<int, ShmemAllocator> MyVector;
  14. int main(int argc, char *argv[])
  15. {
  16.     managed_shared_memory segment(open_only, "MySharedMemory");
  18.     // Test read
  19.     MyVector *vec_test = segment.find<MyVector>("MyVector").first;
  20.     for (auto it = vec_test->begin(); it != vec_test->end(); it++)
  21.         std::cout << (*it) << ",";
  22.     std::cout << std::endl;
  24.     return 0;
  25. };

4 同步

4.1 anonymous mutex

使用 boost::interprocess::interprocess_mutex，可以保证被 mutex guard 的量可以由所有进程访问，因为其是存储在共享内存中的 (与boost::interprocess::named_mutex不同，后者由操作系统管理，并不是共享内存机制，无法跨进程访问)。

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  3. #include <iostream>
  5. using namespace boost::interprocess;
  7. int main()
  8. {
  9.     // bool ret = shared_memory_object::remove("shm");
  10.     // std::cout << std::boolalpha << ret << std::endl;
  12.     managed_shared_memory managed_shm(open_or_create, "shm", 1024);
  13.     int *i = managed_shm.find_or_construct<int>("TheNumber")(80);
  14.     interprocess_mutex *mtx = managed_shm.find_or_construct<interprocess_mutex>("mtx")();
  16.     mtx->lock();
  17.     ++(*i);
  18.     std::cout << *i << '\n';
  19.     mtx->unlock();
  20. }

4.2 用同步方式生产消费一个Vector

Server:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  5. #include <boost/interprocess/sync/interprocess_condition.hpp>
  6. #include <boost/interprocess/sync/scoped_lock.hpp>
  7. #include <string>
  8. //#include <cstdlib> //std::system
  9. #include <iostream>
  11. using namespace boost::interprocess;
  13. typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator;
  14. typedef vector<int, ShmemAllocator> MyVector;
  16. int main(int argc, char *argv[])
  17. {
  18.     shared_memory_object::remove("MySharedMemory");
  19.     managed_shared_memory segment(create_only, "MySharedMemory", 65536);
  21.     interprocess_mutex *mtx = segment.find_or_construct<interprocess_mutex>("mtx")();
  22.     interprocess_condition *cnd = segment.find_or_construct<interprocess_condition>("cnd")();
  23.     scoped_lock<interprocess_mutex> lock{*mtx};
  25.     //Initialize shared memory STL-compatible allocator
  26.     const ShmemAllocator alloc_inst(segment.get_segment_manager());
  27.     MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst);
  29.     // 每次获取锁后，更新vector内容。
  30.     // 然后放开，等 Client 得到后再更新
  31.     int counter = 0;
  32.     while (counter < 10)
  33.     {
  34.         counter++;
  35.         myvector->clear();
  37.         for (int i = 0; i < 10; ++i)
  38.             myvector->push_back(i * counter);
  40.         cnd->notify_all();
  41.         cnd->wait(lock);
  42.     }
  43.     cnd->notify_all();
  45.     shared_memory_object::remove("MySharedMemory");
  47.     return 0;
  48. };

Client:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  5. #include <boost/interprocess/sync/interprocess_condition.hpp>
  6. #include <boost/interprocess/sync/scoped_lock.hpp>
  7. #include <string>
  8. #include <iostream>
  10. using namespace boost::interprocess;
  12. typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator;
  13. typedef vector<int, ShmemAllocator> MyVector;
  15. int main(int argc, char *argv[])
  16. {
  17.     managed_shared_memory segment(open_only, "MySharedMemory");
  19.     interprocess_mutex *mtx = segment.find_or_construct<interprocess_mutex>("mtx")();
  20.     interprocess_condition *cnd = segment.find_or_construct<interprocess_condition>("cnd")();
  21.     scoped_lock<interprocess_mutex> lock{*mtx};
  23.     MyVector *vec_test = segment.find<MyVector>("MyVector").first;
  25.     // 得到数据后放开等待 Server 更新 vector
  26.     int counter = 0;
  27.     while (counter < 10)
  28.     {
  29.         counter++;
  31.         for (auto it = vec_test->begin(); it != vec_test->end(); it++)
  32.             std::cout << (*it) << ",";
  33.         std::cout << std::endl;
  35.         cnd->notify_all();
  36.         cnd->wait(lock);
  37.     }
  38.     cnd->notify_all();
  40.     return 0;
  41. };

4.3 自定义类型的 Vector

只是 Allocator 和上面不一样，应对类似 ESR 毫米波雷达 CAN 数据的情形。
Server:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  5. #include <boost/interprocess/sync/interprocess_condition.hpp>
  6. #include <boost/interprocess/sync/scoped_lock.hpp>
  7. #include <string>
  8. //#include <cstdlib> //std::system
  9. #include <iostream>
  11. using namespace boost::interprocess;
  13. struct some_data
  14. {
  15.     int id;
  16.     double info;
  17. };
  19. typedef allocator<some_data, managed_shared_memory::segment_manager> ShmemAllocator;
  20. typedef vector<some_data, ShmemAllocator> MyVector;
  22. int main(int argc, char *argv[])
  23. {
  24.     shared_memory_object::remove("MySharedMemory");
  25.     managed_shared_memory segment(create_only, "MySharedMemory", 65536);
  27.     interprocess_mutex *mtx = segment.find_or_construct<interprocess_mutex>("mtx")();
  28.     interprocess_condition *cnd = segment.find_or_construct<interprocess_condition>("cnd")();
  29.     scoped_lock<interprocess_mutex> lock{*mtx};
  31.     //Initialize shared memory STL-compatible allocator
  32.     const ShmemAllocator alloc_inst(segment.get_segment_manager());
  33.     MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst);
  35.     int counter = 0;
  36.     while (counter < 10)
  37.     {
  38.         counter++;
  39.         myvector->clear();
  41.         for (int i = 0; i < 10; ++i)
  42.         {
  43.             some_data data{i * counter, 0.2 * counter};
  44.             myvector->push_back(data);
  45.         }
  48.         cnd->notify_all();
  49.         cnd->wait(lock);
  50.     }
  51.     cnd->notify_all();
  53.     shared_memory_object::remove("MySharedMemory");
  55.     return 0;
  56. };

Client:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  5. #include <boost/interprocess/sync/interprocess_condition.hpp>
  6. #include <boost/interprocess/sync/scoped_lock.hpp>
  7. #include <string>
  8. #include <iostream>
  10. using namespace boost::interprocess;
  12. struct some_data
  13. {
  14.     int id;
  15.     double info;
  16. };
  18. typedef allocator<some_data, managed_shared_memory::segment_manager> ShmemAllocator;
  19. typedef vector<some_data, ShmemAllocator> MyVector;
  21. int main(int argc, char *argv[])
  22. {
  23.     managed_shared_memory segment(open_only, "MySharedMemory");
  25.     interprocess_mutex *mtx = segment.find_or_construct<interprocess_mutex>("mtx")();
  26.     interprocess_condition *cnd = segment.find_or_construct<interprocess_condition>("cnd")();
  27.     scoped_lock<interprocess_mutex> lock{*mtx};
  29.     MyVector *vec_test = segment.find<MyVector>("MyVector").first;
  31.     int counter = 0;
  32.     while (counter < 10)
  33.     {
  34.         counter++;
  36.         for (auto it = vec_test->begin(); it != vec_test->end(); it++)
  37.             std::cout << "<" << (*it).id << "," << (*it).info << ">";
  39.         std::cout << std::endl;
  41.         cnd->notify_all();
  42.         cnd->wait(lock);
  43.     }
  44.     cnd->notify_all();
  46.     return 0;
  47. };

4.4 Vector 为成员的自定义类型列表

类似激光雷达点云数据的情形
Server:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  5. #include <boost/interprocess/sync/interprocess_condition.hpp>
  6. #include <boost/interprocess/sync/scoped_lock.hpp>
  7. #include <string>
  8. //#include <cstdlib> //std::system
  9. #include <iostream>
  11. using namespace boost::interprocess;
  13. // 即便一个简单的Vector，也必须这样用 allocator 初始化，否则 Client 找不到？
  14. typedef allocator<double, managed_shared_memory::segment_manager> DoubleAllocator;
  15. typedef vector<double, DoubleAllocator> dVec;
  17. struct some_data
  18. {
  19.     int id;
  20.     dVec info;
  21. };
  23. typedef allocator<some_data, managed_shared_memory::segment_manager> ShmemAllocator;
  24. typedef vector<some_data, ShmemAllocator> MyVector;
  26. int main(int argc, char *argv[])
  27. {
  28.     shared_memory_object::remove("MySharedMemory");
  29.     managed_shared_memory segment(create_only, "MySharedMemory", 65536);
  31.     interprocess_mutex *mtx = segment.find_or_construct<interprocess_mutex>("mtx")();
  32.     interprocess_condition *cnd = segment.find_or_construct<interprocess_condition>("cnd")();
  33.     scoped_lock<interprocess_mutex> lock{*mtx};
  35.     //Initialize shared memory STL-compatible allocator
  36.     const ShmemAllocator alloc_inst(segment.get_segment_manager());
  37.     MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst);
  39.     int counter = 0;
  40.     while (counter < 10)
  41.     {
  42.         counter++;
  43.         myvector->clear();
  45.         for (int i = 0; i < 10; ++i)
  46.         {
  47.             std::stringstream s;
  48.             s << "info_" << counter << "_" << i;
  49.             const DoubleAllocator alloc_inst(segment.get_segment_manager());
  50.             dVec *vec = segment.construct<dVec>(s.str().c_str())(alloc_inst);;
  51.             vec->push_back(0.2 * counter);
  52.             vec->push_back(2.0 * counter);
  54.             some_data data{i * counter, *vec};
  55.             myvector->push_back(data);
  56.         }
  59.         cnd->notify_all();
  60.         cnd->wait(lock);
  61.     }
  62.     cnd->notify_all();
  64.     shared_memory_object::remove("MySharedMemory");
  66.     return 0;
  67. };

Client:

  1. #include <boost/interprocess/managed_shared_memory.hpp>
  2. #include <boost/interprocess/containers/vector.hpp>
  3. #include <boost/interprocess/allocators/allocator.hpp>
  4. #include <boost/interprocess/sync/interprocess_mutex.hpp>
  5. #include <boost/interprocess/sync/interprocess_condition.hpp>
  6. #include <boost/interprocess/sync/scoped_lock.hpp>
  7. #include <string>
  8. #include <iostream>
  10. using namespace boost::interprocess;
  12. typedef allocator<double, managed_shared_memory::segment_manager> DoubleAllocator;
  13. typedef vector<double, DoubleAllocator> dVec;
  15. struct some_data
  16. {
  17.     int id;
  18.     dVec info;
  19. };
  21. typedef allocator<some_data, managed_shared_memory::segment_manager> ShmemAllocator;
  22. typedef vector<some_data, ShmemAllocator> MyVector;
  24. int main(int argc, char *argv[])
  25. {
  26.     managed_shared_memory segment(open_only, "MySharedMemory");
  28.     interprocess_mutex *mtx = segment.find_or_construct<interprocess_mutex>("mtx")();
  29.     interprocess_condition *cnd = segment.find_or_construct<interprocess_condition>("cnd")();
  30.     scoped_lock<interprocess_mutex> lock{*mtx};
  32.     MyVector *vec_test = segment.find<MyVector>("MyVector").first;
  34.     int counter = 0;
  35.     while (counter < 10)
  36.     {
  37.         counter++;
  39.         for (auto it = vec_test->begin(); it != vec_test->end(); it++)
  40.             std::cout << "<" << (*it).id << ":" << (*it).info[0] << "," << (*it).info[1] << ">";
  42.         std::cout << std::endl;
  44.         cnd->notify_all();
  45.         cnd->wait(lock);
  46.     }
  47.     cnd->notify_all();
  49.     return 0;
  50. };
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注