我正在尝试在以下类型的共享内存中构建一个地图
我像这样创建共享内存区域：
managed_shared_memory segment(create_only ,"MyMap" ,size);
ShMemAllocator_t alloc_inst (segment.get_segment_manager());
map = segment.construct<MyMap_t>("MyMap")
(std::less<int>()
,alloc_inst);
地图中的值如下：
typedef pair<MutexType, boost::interprocess::offset_ptr<void> > ValueType ;
MutexType本身是一个包含读取和写入互斥的结构（使用read_lock和write_lock）; 定义如下：
typedef struct mutex_struct{
sharable_lock<interprocess_mutex> read_lock(interprocess_mutex, defer_lock);
scoped_lock<interprocess_mutex> write_lock(interprocess_mutex, defer_lock);
} MutexType;
“size”是地图的总大小（就对象而言，所有void指针指向的数据大小的总和）。
如何确保此void *数据也位于我创建的内存段中，如何在现有共享内存区域内实例化它。这样做的原因是我想只分配一次这个大缓冲区，但是反复删除/添加对象（地图模拟缓存）我还没有找到一种方法，可以在同一个内存段中分配多个对象在地图内。此外，寻求分配MutexType对返回编译错误，指出没有提供“call”操作符。
答案 0 :(得分：12)
你基本上已经在那里了。调用您在共享内存SecondValue_t中分配的任何对象类型。而不是ShMemAllocator_t，定义一个不同的进程间分配器类型，比如SecondValueAllocator_t，用于分配SecondValue_t个对象。每当您想要将ValueType对象插入到地图中时，ValueType对象的第二个值就会与SecondValueAllocator_t实例一起分配。
以下是一个完整的示例，部分使用my answer Interprocess reader/writer lock with Boost中的代码：
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include <utility>
#include <boost/scope_exit.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/allocators/private_node_allocator.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/sync/sharable_lock.hpp>
#include <boost/interprocess/sync/upgradable_lock.hpp>
#define SHARED_MEMORY_NAME "SO13783012-MyMap"
// https://stackoverflow.com/questions/13783012/map-of-int-void-in-shared-memory-using-boostinterprocess
using namespace boost::interprocess;
typedef int SecondValue_t;
typedef allocator<SecondValue_t, managed_shared_memory::segment_manager> SecondValueAllocator_t;
typedef struct mutex_struct {
//...
} MutexType;
typedef std::pair<MutexType, SecondValueAllocator_t::pointer> ValueType;
typedef map<int, ValueType>::value_type MyMapValueType;
typedef allocator<MyMapValueType, managed_shared_memory::segment_manager> MyMapEntryAllocator_t;
typedef map<int, ValueType, std::less<int>, MyMapEntryAllocator_t> MyMap_t;
struct shared_data {
private:
typedef boost::interprocess::interprocess_upgradable_mutex upgradable_mutex_type;
mutable upgradable_mutex_type mutex;
MyMap_t my_map;
public:
shared_data(const MyMapEntryAllocator_t& alloc)
: my_map(MyMap_t::key_compare(), alloc)
{
}
// Tries to get the mapped value for the given key `k'. If successful, the mapped value is
// copied into `out' and `true' is returned. Otherwise, returns `false' and does not modify
// `out'.
bool try_get(MyMap_t::mapped_type& out, MyMap_t::key_type k) const {
boost::interprocess::sharable_lock<upgradable_mutex_type> lock(mutex);
MyMap_t::const_iterator pos = my_map.find(k);
if (pos != my_map.end()) {
out = pos->second;
return true;
}
return false;
}
void put(MyMap_t::key_type k, MyMap_t::mapped_type v) {
boost::interprocess::scoped_lock<upgradable_mutex_type> lock(mutex);
my_map.insert(MyMap_t::value_type(my_map.size(), v));
}
};
int main(int argc, char *argv[])
{
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " WHICH\n";
return EXIT_FAILURE;
}
const std::string which = argv[1];
if (which == "parent") {
shared_memory_object::remove(SHARED_MEMORY_NAME);
BOOST_SCOPE_EXIT(argc) {
shared_memory_object::remove(SHARED_MEMORY_NAME);
} BOOST_SCOPE_EXIT_END;
managed_shared_memory shm(create_only, SHARED_MEMORY_NAME, 65536);
MyMapEntryAllocator_t entry_alloc(shm.get_segment_manager());
shared_data& d = *shm.construct<shared_data>("theSharedData")(entry_alloc);
SecondValueAllocator_t second_value_alloc(shm.get_segment_manager());
// Insert some test data.
SecondValueAllocator_t::pointer p;
p = second_value_alloc.allocate(1);
second_value_alloc.construct(p, -3);
d.put(0, std::make_pair(MutexType(), p));
p = second_value_alloc.allocate(1);
second_value_alloc.construct(p, 70);
d.put(1, std::make_pair(MutexType(), p));
p = second_value_alloc.allocate(1);
second_value_alloc.construct(p, -18);
d.put(2, std::make_pair(MutexType(), p));
p = second_value_alloc.allocate(1);
second_value_alloc.construct(p, 44);
d.put(3, std::make_pair(MutexType(), p));
p = second_value_alloc.allocate(1);
second_value_alloc.construct(p, 0);
d.put(4, std::make_pair(MutexType(), p));
// Go to sleep for a minute - gives us a chance to start a child process.
sleep(60);
} else {
managed_shared_memory shm(open_only, SHARED_MEMORY_NAME);
std::pair<shared_data *, std::size_t> find_res = shm.find<shared_data>("theSharedData");
if (!find_res.first) {
std::cerr << "Failed to find `theSharedData'.\n";
return EXIT_FAILURE;
}
shared_data& d = *find_res.first;
MyMap_t::mapped_type v;
int i = 0;
for (; d.try_get(v, i); ++i) {
std::cout << i << ": " << *v.second << '\n';
}
// Add an entry.
srand(time(NULL));
SecondValueAllocator_t second_value_alloc(shm.get_segment_manager());
SecondValueAllocator_t::pointer p = second_value_alloc.allocate(1);
second_value_alloc.construct(p, (rand() % 200) - 100);
d.put(i, v = std::make_pair(MutexType(), p));
std::cout << "placed " << *v.second << " into the map.\n";
}
return EXIT_SUCCESS;
}
首先启动父进程测试它：
./SO13783012 parent
然后是一些孩子：
./SO13783012 child
示例输出：
> ./SO13783012 child 0: -3 1: 70 2: -18 3: 44 4: 0 placed 5: -63 into the map. > ./SO13783012 child 0: -3 1: 70 2: -18 3: 44 4: 0 5: -63 placed 6: -42 into the map. > ./SO13783012 child 0: -3 1: 70 2: -18 3: 44 4: 0 5: -63 6: -42 placed 7: -28 into the map.
答案 1 :(得分：0)
您可以在allocator＆lt;＆gt;
中使用rebind// convert an allocator<T> to allocator<U>
template<typename U>
struct rebind {
typedef Allocator<U> other;
};
制作
typedef std::allocator< char, managed_shared_memory::segment_manager > char_alloc;
然后像这样分配你的记忆
char_alloc char_alloc_obj;
char * ptr = new (char_alloc_obj.allocate(size)) char[size];
void * vptr = (void *) ptr;
默认的std :: allocator＆lt;＆gt;是国家少。共享内存分配器将具有状态，因此您需要弄清楚如何在不同类型的分配器之间复制状态。