Карты карт, размещенных в общей памяти

Ok.

Итак, было несколько основных ошибок и, возможно, некоторая путаница.

Далее, есть несколько мощных приемов, которые делают использование вложенных контейнеров с настраиваемыми (с отслеживанием состояния) распределителями намного удобнее.

Вот сводка всех трех подсказок в рабочем образце, который, надеюсь, поможет!

1. Ваши строки должны также использовать распределители общей памяти

   В противном случае данные нельзя было бы использовать в другом процессе. Использование строк приведет к неопределенному поведению.

   По крайней мере, пусть ваши строки используют распределитель разделяемой памяти:

   namespace Shared {
       using Segment   = bip::managed_shared_memory;
   
       template <typename T>
       using Alloc     = bip::allocator<T, Segment::segment_manager>;
   
       using String    = boost::container::basic_string<char, std::char_traits<char>, Alloc<char> >;
       using KeyType   = String;
       using ValueType = String;
   }
   

2. Распределители карты были определены с завышением. Фактические типы узлов, заключающие pair<K const, v> элементы в карту, в любом случае определяются реализацией. Итак, как карты узнают, как распределять эти узлы?

   Они повторно связывают распределители: см. rebind < / a> в документации здесь

   Итак, вы можете просто передать Alloc<void>. Или тот же распределитель, что и для Shared::String. Карта разберется:

   typedef boost::unordered_map<KeyType, ValueType, boost::hash<KeyType>, std::equal_to<KeyType>, Alloc<void> > InMap;
   typedef boost::unordered_map<KeyType, InMap,     boost::hash<KeyType>, std::equal_to<KeyType>, Alloc<void> > OutMap;
   

3. Теперь о советах по мощности.

   Постоянная передача распределителей с отслеживанием состояния раздражает. Это делает код беспорядком. К счастью, c ++ 11 (и Boost Containers для c ++ 03) поможет вам:

   • scoped_allocator_adaptor<T...>
   • allocator_type
   • uses_allocator<T> черта

   Эти помощники могут значительно облегчить вашу жизнь. Они делают это, передавая распределитель конструкторам типов элементов, когда это применимо. Автоматически. Опять же, неявные преобразования из типов распределителей повторного связывания заставляют все работать.

   Таким образом, вы можете на самом деле просто построить одну внешнюю карту с правильным распределителем (сделайте это Scoped) и одним ключом, и оттуда вам даже не придется постоянно указывать распределители.

Live On Coliru

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/container/scoped_allocator.hpp>
#include <boost/unordered_map.hpp>
#include <iostream>

namespace bip = boost::interprocess;

namespace Shared {
    using Segment = bip::managed_shared_memory;

    template <typename T>
    using Alloc   = bip::allocator<T, Segment::segment_manager>;
    using Scoped  = boost::container::scoped_allocator_adaptor<Alloc<char> >;

    using String  = boost::container::basic_string<char, std::char_traits<char>, Scoped>;
    using KeyType = String;

    typedef boost::unordered_map<KeyType, String, boost::hash<KeyType>, std::equal_to<KeyType>, Scoped> InMap;
    typedef boost::unordered_map<KeyType, InMap,  boost::hash<KeyType>, std::equal_to<KeyType>, Scoped> OutMap;
}

int main() {
    srand(time(NULL));

    Shared::Segment segment(bip::open_or_create, "BOOST_SHM", 65536);
    auto* mgr = segment.get_segment_manager();

    Shared::OutMap *p_outside_map = segment.find_or_construct<Shared::OutMap> ("SHM_OUT_MAP") (mgr);
    auto& outside_map = *p_outside_map;

    Shared::String sskey(mgr); // reduce shared allocations as they are costly (in terms of fragmentation/overhead)

    char outer_keys[3], inner_keys[3];
    std::generate_n(outer_keys, 3, [] { return rand()%26+'a'; });
    std::generate_n(inner_keys, 3, [] { return rand()%26+'a'; });

    for (auto key : outer_keys) {
        sskey = key;
        auto& inner = outside_map[sskey];

        for (auto more : inner_keys) {
            inner[sskey + "_" + more] += "value";
        }
    }

    for (auto const& oe : outside_map) {
        for (auto const& ie : oe.second) {
            std::cout << "outside_map[" << oe.first << "][" << ie.first << "] == " << ie.second << "\n";
        }
    }
}

На самом деле, чтобы он работал на Coliru, нам нужно вместо этого использовать сопоставленный файл:

Live On Coliru

Запустите его несколько раз:

outside_map[s][s_t] == value
outside_map[s][s_r] == value
outside_map[s][s_c] == value
outside_map[f][f_t] == value
outside_map[f][f_r] == value
outside_map[f][f_c] == value
outside_map[o][o_t] == value
outside_map[o][o_r] == value
outside_map[o][o_c] == value

Второй прогон:

outside_map[a][a_d] == value
outside_map[a][a_c] == value
outside_map[a][a_g] == value
outside_map[r][r_d] == value
outside_map[r][r_c] == value
outside_map[r][r_g] == value
outside_map[g][g_d] == value
outside_map[g][g_c] == value
outside_map[g][g_g] == value
outside_map[s][s_t] == value
outside_map[s][s_r] == value
outside_map[s][s_c] == value
outside_map[f][f_t] == value
outside_map[f][f_r] == value
outside_map[f][f_c] == value
outside_map[o][o_t] == value
outside_map[o][o_r] == value
outside_map[o][o_c] == value

Обратите внимание, как каждый прогон успешно добавляет value к 9 ключам в 3 внутренних картах.