#ifndef NO_CPP0X #include "SharedMemory.h" #include "lib/utils/bts_assert.h" #include "lib/logging/logging.h" #include #include #include #include #include #include #include using namespace std; using namespace boost::interprocess; namespace bts { namespace utils { struct BoostLowLevelSharedMemoryImpl; class BoostLowLevelSharedMemory : public LowLevelSharedMemory { std::unique_ptr _me; public: BoostLowLevelSharedMemory(); // Inherited via LowLevelSharedMemory virtual Segment create(const std::string & name, size_t size) override; virtual const Segment open(const std::string& name, bool read_only) override; virtual bool release(const std::string & name) override; }; struct PrivateSharedMemoryImpl; struct RcSegment { RcSegment() : name(""), size(0), buffer() {} RcSegment(string n, size_t s) : name(n), size(s), buffer(make_shared>(s)) {} string name; size_t size; std::shared_ptr> buffer; byte* data() const { return buffer ? &(*buffer)[0] : nullptr; } operator Segment() const { Segment s = { size, data() }; return s; } }; class PrivateSharedMemory : public LowLevelSharedMemory { vector> _segments; public: PrivateSharedMemory(); ~PrivateSharedMemory(); // Inherited via LowLevelSharedMemory virtual Segment create(const std::string & name, size_t size) override; virtual const Segment open(const std::string& name, bool read_only) override; virtual bool release(const std::string & name) override; }; /* * Boot shared memory impl */ Segment make_segment(size_t size, void* ptr) { Segment s = {size, (byte*)ptr }; return s; } struct BoostLowLevelSharedMemoryImpl { BoostLowLevelSharedMemoryImpl() : _mappings() { } void add_region(shared_memory_object block) { mapped_region region(block, block.get_mode()); _mappings.push_back(make_pair(move(block), move(region))); } Segment create(const string & name, size_t size) { try { shared_memory_object block(create_only, name.c_str(), read_write); block.truncate(size); add_region(move(block)); return make_segment(size, _mappings.back().second.get_address()); } catch (...) { return make_segment(0, nullptr); } } Segment open(const string& name, bool ro) { try { add_region(shared_memory_object(open_only, name.c_str(), ro ? read_only : read_write)); return make_segment(_mappings.back().second.get_size(), _mappings.back().second.get_address()); } catch (...) { return make_segment(0, nullptr); } } bool release(const string& segment_name) { _mappings.erase( remove_if(_mappings.begin(), _mappings.end(), [&](const pair& p) { return p.first.get_name() == segment_name; }), _mappings.end()); LOG(md,Diag, "Remove shared memory segment: {}" , std::string(segment_name)); return boost::interprocess::shared_memory_object::remove(segment_name.c_str()); } vector> _mappings; }; BoostLowLevelSharedMemory::BoostLowLevelSharedMemory() : _me(std::make_unique()) {} Segment utils::BoostLowLevelSharedMemory::create(const string & name, size_t size) { return _me->create(name, size); } const Segment BoostLowLevelSharedMemory::open(const std::string & name, bool read_only) { return _me->open(name, read_only); } bool utils::BoostLowLevelSharedMemory::release(const string & name) { return _me->release(name); } /* * Non-shared memory implementation */ struct PrivateSharedMemoryImpl { PrivateSharedMemoryImpl() : _mutex(), _mallocs() {} std::mutex _mutex; map _mallocs; RcSegment create(const string & name, size_t size) { std::lock_guard lock(_mutex); RcSegment segment(name, size); // If an old segment existed it is discarded _mallocs[name] = segment; return segment; } RcSegment open(const string& name, bool) { std::lock_guard lock(_mutex); auto find_result = _mallocs.find(name); if (find_result != _mallocs.end()) { return find_result->second; } return RcSegment(); } bool release(const string& name) { std::lock_guard lock(_mutex); auto find_result = _mallocs.find(name); if (find_result != _mallocs.end()) { _mallocs.erase(name); return true; } return false; } static PrivateSharedMemoryImpl& instance() { static PrivateSharedMemoryImpl impl; return impl; } }; PrivateSharedMemory::PrivateSharedMemory() : _segments() {} PrivateSharedMemory::~PrivateSharedMemory() { for (auto& pair : _segments) { bool owned = pair.first; if (owned) { PrivateSharedMemoryImpl::instance().release(pair.second.name); } } } Segment PrivateSharedMemory::create(const string & name, size_t size) { auto result = PrivateSharedMemoryImpl::instance().create(name, size); if (result.buffer) _segments.push_back(make_pair(true, result)); return (Segment)result; } const Segment PrivateSharedMemory::open(const std::string & name, bool read_only) { auto result = PrivateSharedMemoryImpl::instance().open(name, read_only); if (result.buffer) _segments.push_back(make_pair(false, result)); return (Segment)result; } bool PrivateSharedMemory::release(const string & name) { return PrivateSharedMemoryImpl::instance().release(name); } std::unique_ptr create_low_level_shared_memory(bool shared) { return unique_ptr(shared ? static_cast(new BoostLowLevelSharedMemory()) : static_cast(new PrivateSharedMemory())); } }}//namespace #endif