8

次のタイプの共有メモリにマップを構築しようとしています

次のように共有メモリ領域を作成します。

 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;

「サイズ」は、マップの合計サイズです (オブジェクトに関しては、すべての void ポインターが指すデータ サイズの合計です)。

この void* データが、作成したこのメモリ セグメントにも配置されていることを確認するにはどうすればよいですか? 既存の共有メモリ領域内でインスタンス化するにはどうすればよいでしょうか)。これを行う理由は、この大きなバッファーを一度だけ割り当てたいが、オブジェクトを繰り返し削除/追加したい (マップはキャッシュをモデル化する) ことです。同じメモリセグメント内で複数のオブジェクトを割り当てる方法をまだ見つけていません。マップ内。さらに、MutexType ペアを割り当てようとすると、「呼び出し」演算子が提供されていないことを示すコンパイル エラーが返されます。

4

2 に答える 2

13

あなたは基本的にすでにそこにいます。共有メモリに割り当てているオブジェクト タイプを呼び出しますSecondValue_t。の代わりにShMemAllocator_t、別のインタープロセス アロケータ タイプ、たとえば を定義しSecondValueAllocator_tて、オブジェクトを割り当てSecondValue_tます。ValueTypeオブジェクトをマップに挿入するときはいつでも、オブジェクトの 2 番目の値がインスタンスValueTypeに割り当てられSecondValueAllocator_tます。

これは、 Boost を使用した Interprocess リーダー/ライター ロックに対する私の回答のコードを部分的に使用した完全な例です。

#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 親

次に、いくつかの子供たち：

./SO13783012 子

出力例:

> ./SO13783012 子
0: -3
1:70
2: -18
3:44
4:0
5: -63 をマップに配置しました。
> ./SO13783012 子
0: -3
1:70
2: -18
3:44
4:0
5: -63
6: -42 をマップに配置しました。
> ./SO13783012 子
0: -3
1:70
2: -18
3:44
4:0
5: -63
6: -42
マップに 7: -28 を配置しました。
于 2012-12-16T21:01:55.250 に答える
0

allocator<> で 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<> はステートレスです。共有メモリ アロケータには状態があるため、異なるタイプのアロケータ間で状態をコピーする方法を理解する必要があります。

于 2012-12-16T16:24:19.517 に答える