C++ Boost ICL контейнеры в разделяемой памяти
Я работаю с boost::icl::interval_map, который работает отлично, но я хочу, чтобы этот контейнер был сохранен в общей памяти. Обеспечивает ли boost поддержку хранения контейнеров boost:: icl в разделяемой памяти?
using namespace std;
using namespace boost::icl;
struct IFM {
std::string destinationGroup;
int priority;
IFM()
{
destinationGroup= "";
priority = 0;
}
IFM(const std::string& d, const int& p)
{
destinationGroup= d;
priority = p;
}
IFM& operator +=(const IFM& right)
{
destinationGroup+= right.destinationGroup;
priority += right.priority;
return *this;
}
bool operator <(const IFM& left) const {
if(priority < left.priority)
return true;
}
bool operator ==(const IFM& left) const {
return destinationGroup== left.destinationGroup
&& priority == left.priority;
}
};
typedef std::set<IFM> guests;
void boost_party()
{
interval_map<double, guests> party;
IFM i = {"123", 1};
IFM j = {"124", 1};
IFM k = {"126", 2,};
IFM l = {"128", 1};
IFM m = {"129", 1};
IFM n = {"130", 1};
guests ii;
ii.insert(i);
guests jj;
jj.insert(j);
guests kk;
kk.insert(k);
guests ll;
ll.insert(l);
guests mm;
mm.insert(m);
party.add(make_pair(interval<double>::closed(12345600000,12345699999), guests(ii)));
party.add(make_pair(interval<double>::closed(32100000000,32199999999), guests(jj)));
party.add(make_pair(interval<double>::closed(42000000000,42999999999), guests(ll)));
party.add(make_pair(interval<double>::closed(42101000000,42101099999), guests(kk)));
party.add(make_pair(interval<double>::closed(67000000000,67999999999), guests(mm)));
interval_map<double, guests>::const_iterator it;
it = party.find(42101035898);
if (it != party.end()) {
interval<double>::type when = it->first;
guests who = (*it++).second;
cout << who.size() << endl;
for (auto it2 : who) {
cout << when << ": " << it2.destinationGroup<< endl;
}
}
}
int main() {
boost_party();
return 0;
}
Дает мне следующий вывод, который ожидается Теперь я пытаюсь поместить простую карту interval_map в разделяемую память, но мой код никогда не компилируется
boost::interprocess::managed_shared_memory segment(
boost::interprocess::create_only, "MySharedMemory" //segment name
, 65536);
typedef int KeyType;
typedef int MappedType;
typedef pair<int,int> keyvalue;
typedef boost::interprocess::allocator<keyvalue, boost::interprocess::managed_shared_memory::segment_manager>
ShmemAllocator;
ShmemAllocator alloc_inst (segment.get_segment_manager());
typedef boost::icl::interval_map<int, int, boost::icl::partial_absorber, std::less, boost::icl::inplace_plus,boost::icl::inter_section, boost::icl::discrete_interval<int, std::less>, ShmemAllocator> MyMap;
Дай следующую ошибку
ошибка: несоответствие типа / значения в аргументе 8 в списке параметров шаблона для 'шаблона класса Сравнить, класса шаблона Combine, класса шаблона Section, класса Interval, класса шаблона Alloc> класс boost::icl::interval_map' typedef boost:: icl:: интервал_карта, ShmemAllocator> MyMap;
ошибка: ожидал шаблон класса, получил 'ShmemAllocator {aka boost::interprocess::allocator, boost::interprocess:: сегмент_manager, boost::interprocess::iset_index> >}'
ошибка: неверный тип в объявлении перед ';' знак
1 ответ
На данный момент ошибка компилятора указывает, что вы передаете тип в качестве аргумента шаблона, где ожидался (переменный) аргумент шаблона шаблона.
Технически вы можете добиться этого, используя псевдонимы C++11:
template <typename T> using allocator = bip::allocator<T, smgr>;
template<typename T> using set = std::set<T, allocator<T> >;
template <typename Domain, typename Codomain>
using basic_map = icl::interval_map<Domain, Codomain,
icl::partial_absorber, std::less, icl::inplace_plus, icl::inter_section, icl::discrete_interval<int, std::less>,
allocator
>;
Тем не менее, это не приведет к рабочему коду, как я нашел в моем сеансе livecoding. Проблема заключается в том, что Boost ICL в настоящее время не поддерживает распределители с сохранением состояния.
Это означает, что не все конструкторы принимают экземпляр распределителя для передачи в требуемое состояние.
К сожалению, это означает, что только хакерский пользовательский распределитель может работать, когда пользовательский распределитель будет ссылаться на ваш сегмент совместно используемой памяти по глобальной ссылке.
демонстрация
Вот демонстрация, которая показывает подтверждение концепции с таким распределителем глобального сегмента:
#include <boost/icl/interval_map.hpp>
#include <boost/interprocess/managed_mapped_file.hpp>
#include <iostream>
#include <vector>
#include <set>
namespace bip = boost::interprocess;
namespace icl = boost::icl;
namespace shared {
using segment = bip::managed_mapped_file;
using smgr = segment::segment_manager;
}
namespace {
static bip::managed_mapped_file global_mm(bip::open_or_create, "./demo.bin", 1ul<<20);
static bip::allocator<void, shared::smgr> global_alloc(global_mm.get_segment_manager());
template <class T> struct SimpleAllocator : std::allocator<T> { // inheriting the nested typedefs only
typedef T value_type;
SimpleAllocator() : _alloc(global_alloc) {}
template <class U>
SimpleAllocator(const SimpleAllocator<U> &other) : _alloc(other._alloc) {}
T* allocate(std::size_t n) { return std::addressof(*_alloc.allocate(n)); }
void deallocate(T *p, std::size_t n) { _alloc.deallocate(p, n); }
// optionals
template <typename Other> struct rebind { typedef SimpleAllocator<Other> other; };
bip::allocator<T, shared::smgr> _alloc;
};
template <class T, class U> bool operator==(const SimpleAllocator<T> &, const SimpleAllocator<U> &) { return true; }
template <class T, class U> bool operator!=(const SimpleAllocator<T> &, const SimpleAllocator<U> &) { return false; }
}
namespace shared {
template <typename T> using allocator = SimpleAllocator<T>;
template<typename T> using set = std::set<T, std::less<T>, allocator<T> >;
template <typename Domain, typename Codomain>
using basic_map = icl::interval_map<Domain, Codomain,
icl::partial_absorber, std::less, icl::inplace_plus, icl::inter_section, icl::discrete_interval<int, std::less>,
allocator
>;
using map = basic_map<int, set<int> >;
using interval = map::interval_type;
}
#include <iostream>
int main() {
shared::map demo;
for (auto&& element : {
shared::map::value_type { shared::interval::right_open(4, 5), { 1, 7, } },
shared::map::value_type { shared::interval::right_open(2, 6), { 1, 2, 3, } },
})
{
demo.add(element);
std::cout << "adding: " << element.first << ", result: " << demo << "\n";
}
}
я использовал managed_mapped_file вместо maneged_shared_memory потому что последний не поддерживается онлайн-компилятором.
¹ или используя "функцию типа" в C++03