Files
spark/src/lib/utils/SharedMemory.cpp
T

215 lines
6.5 KiB
C++

#ifndef NO_CPP0X
#include "SharedMemory.h"
#include "lib/logging/logging.h"
#include "lib/utils/bts_assert.h"
#include <algorithm>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/shared_memory_object.hpp>
using namespace std;
using namespace boost::interprocess;
namespace bts {
namespace utils {
struct BoostLowLevelSharedMemoryImpl;
class BoostLowLevelSharedMemory : public LowLevelSharedMemory {
std::unique_ptr<BoostLowLevelSharedMemoryImpl> _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<vector<byte>>(s)) {}
string name;
size_t size;
std::shared_ptr<vector<byte>> buffer;
byte *data() const { return buffer ? &(*buffer)[0] : nullptr; }
operator Segment() const {
Segment s = {size, data()};
return s;
}
};
class PrivateSharedMemory : public LowLevelSharedMemory {
vector<pair<bool, RcSegment>> _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(std::move(block), std::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(std::move(block));
return make_segment(size, _mappings.back().second.get_address());
} catch (const boost::interprocess::interprocess_exception &ex) {
LOG(md, Error,
"SharedMemory::create interprocess_exception what: {} error_code: "
"{} native_error: {}",
std::string(ex.what()), static_cast<int>(ex.get_error_code()),
ex.get_native_error());
return make_segment(0, nullptr);
} catch (...) {
LOG(md, Error, "SharedMemory::create unknown exception");
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<shared_memory_object, mapped_region> &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<pair<shared_memory_object, mapped_region>> _mappings;
};
BoostLowLevelSharedMemory::BoostLowLevelSharedMemory()
: _me(std::make_unique<BoostLowLevelSharedMemoryImpl>()) {}
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<string, RcSegment> _mallocs;
RcSegment create(const string &name, size_t size) {
std::lock_guard<std::mutex> 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<std::mutex> 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<std::mutex> 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<LowLevelSharedMemory>
create_low_level_shared_memory(bool shared) {
return unique_ptr<LowLevelSharedMemory>(
shared ? static_cast<LowLevelSharedMemory *>(
new BoostLowLevelSharedMemory())
: static_cast<LowLevelSharedMemory *>(new PrivateSharedMemory()));
}
} // namespace utils
} // namespace bts
#endif