Mirror/FairMQ
1
0
Fork 0
mirror of https://github.com/FairRootGroup/FairMQ.git synced 2025-10-16 01:51:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

FairMQ: shared memory unmanaged region updates:

Browse Source 
- use same mapping for sender/receiver (created/remote) region.
 - rename FairMQRegion -> FairMQUnmanagedRegion.
This commit is contained in:
Alexey Rybalchenko
2017-10-19 11:17:05 +02:00
committed by Mohammad Al-Turany
parent f7d3a5e8ae
commit 0bb866ff36
24 changed files with 212 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
fairmq/shmem/FairMQMessageSHM.cxx
View File

@@ -1,15 +1,15 @@
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
#include <string>
#include <cstdlib>
#include "FairMQMessageSHM.h"
#include "FairMQRegionSHM.h"
#include "FairMQUnmanagedRegionSHM.h"
#include "FairMQLogger.h"
#include "FairMQShmCommon.h"
@@ -18,15 +18,11 @@ using namespace fair::mq::shmem;
namespace bipc = boost::interprocess;
// uint64_t FairMQMessageSHM::fMessageID = 0;
// string FairMQMessageSHM::fDeviceID = string();
atomic<bool> FairMQMessageSHM::fInterrupted(false);
FairMQ::Transport FairMQMessageSHM::fTransportType = FairMQ::Transport::SHM;
FairMQMessageSHM::FairMQMessageSHM()
: fMessage()
// , fOwner(nullptr)
// , fReceiving(false)
, fQueued(false)
, fMetaCreated(false)
, fRegionId(0)
@@ -42,15 +38,8 @@ FairMQMessageSHM::FairMQMessageSHM()
fMetaCreated = true;
}
// void FairMQMessageSHM::StringDeleter(void* /*data*/, void* str)
// {
// delete static_cast<string*>(str);
// }
FairMQMessageSHM::FairMQMessageSHM(const size_t size)
: fMessage()
// , fOwner(nullptr)
// , fReceiving(false)
, fQueued(false)
, fMetaCreated(false)
, fRegionId(0)
@@ -64,8 +53,6 @@ FairMQMessageSHM::FairMQMessageSHM(const size_t size)
FairMQMessageSHM::FairMQMessageSHM(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
: fMessage()
// , fOwner(nullptr)
// , fReceiving(false)
, fQueued(false)
, fMetaCreated(false)
, fRegionId(0)
@@ -88,13 +75,11 @@ FairMQMessageSHM::FairMQMessageSHM(void* data, const size_t size, fairmq_free_fn
}
}
FairMQMessageSHM::FairMQMessageSHM(FairMQRegionPtr& region, void* data, const size_t size)
FairMQMessageSHM::FairMQMessageSHM(FairMQUnmanagedRegionPtr& region, void* data, const size_t size)
: fMessage()
// , fOwner(nullptr)
// , fReceiving(false)
, fQueued(false)
, fMetaCreated(false)
, fRegionId(static_cast<FairMQRegionSHM*>(region.get())->fRegionId)
, fRegionId(static_cast<FairMQUnmanagedRegionSHM*>(region.get())->fRegionId)
, fHandle()
, fSize(size)
, fLocalPtr(data)
@@ -113,11 +98,6 @@ FairMQMessageSHM::FairMQMessageSHM(FairMQRegionPtr& region, void* data, const si
header.fHandle = fHandle;
header.fRegionId = fRegionId;
memcpy(zmq_msg_data(&fMessage), &header, sizeof(MetaHeader));
// placement new fails in some environments, TODO: investigate why:
// MetaHeader* metaPtr = new(zmq_msg_data(&fMessage)) MetaHeader();
// metaPtr->fSize = size;
// metaPtr->fHandle = fHandle;
// metaPtr->fRegionId = fRegionId;
fMetaCreated = true;
}
@@ -125,18 +105,11 @@ FairMQMessageSHM::FairMQMessageSHM(FairMQRegionPtr& region, void* data, const si
bool FairMQMessageSHM::InitializeChunk(const size_t size)
{
// string chunkID = fDeviceID + "c" + to_string(fMessageID);
// string* ownerID = new string(fDeviceID + "o" + to_string(fMessageID));
while (!fHandle)
{
try
{
fLocalPtr = Manager::Instance().Segment()->allocate(size);
// fOwner = Manager::Instance().Segment()->construct<ShPtrOwner>(ownerID->c_str())(
// make_managed_shared_ptr(Manager::Instance().Segment()->construct<Chunk>(chunkID.c_str())(size),
// *(Manager::Instance().Segment())));
}
catch (bipc::bad_alloc& ba)
{
@@ -166,19 +139,9 @@ bool FairMQMessageSHM::InitializeChunk(const size_t size)
header.fHandle = fHandle;
header.fRegionId = fRegionId;
memcpy(zmq_msg_data(&fMessage), &header, sizeof(MetaHeader));
// MetaHeader* metaPtr = new(zmq_msg_data(&fMessage)) MetaHeader();
// metaPtr->fSize = size;
// metaPtr->fHandle = fHandle;
// metaPtr->fRegionId = fRegionId;
// if (zmq_msg_init_data(&fMessage, const_cast<char*>(ownerID->c_str()), ownerID->length(), StringDeleter, ownerID) != 0)
// {
// LOG(ERROR) << "failed initializing meta message, reason: " << zmq_strerror(errno);
// }
fMetaCreated = true;
// ++fMessageID;
return true;
}
@@ -186,7 +149,6 @@ void FairMQMessageSHM::Rebuild()
{
CloseMessage();
// fReceiving = false;
fQueued = false;
if (zmq_msg_init(&fMessage) != 0)
@@ -200,7 +162,6 @@ void FairMQMessageSHM::Rebuild(const size_t size)
{
CloseMessage();
// fReceiving = false;
fQueued = false;
InitializeChunk(size);
@@ -210,7 +171,6 @@ void FairMQMessageSHM::Rebuild(void* data, const size_t size, fairmq_free_fn* ff
{
CloseMessage();
// fReceiving = false;
fQueued = false;
if (InitializeChunk(size))
@@ -248,35 +208,17 @@ void* FairMQMessageSHM::GetData()
{
if (!fRemoteRegion)
{
fRemoteRegion = FairMQRegionPtr(new FairMQRegionSHM(fRegionId, true));
fRemoteRegion = FairMQUnmanagedRegionSHM::GetRemoteRegion(fRegionId);
}
fLocalPtr = reinterpret_cast<char*>(fRemoteRegion->GetData()) + fHandle;
fLocalPtr = reinterpret_cast<char*>(fRemoteRegion->get_address()) + fHandle;
return fLocalPtr;
}
}
// if (fOwner)
// {
// return fOwner->fPtr->GetData();
// }
// else
// {
// LOG(ERROR) << "Trying to get data of an empty shared memory message";
// exit(EXIT_FAILURE);
// }
}
size_t FairMQMessageSHM::GetSize()
{
return fSize;
// if (fOwner)
// {
// return fOwner->fPtr->GetSize();
// }
// else
// {
// return 0;
// }
}
void FairMQMessageSHM::SetMessage(void*, const size_t)
@@ -315,81 +257,15 @@ void FairMQMessageSHM::Copy(const unique_ptr<FairMQMessage>& msg)
{
LOG(ERROR) << "FairMQMessageSHM::Copy() fail: target message already initialized!";
}
// version with sharing the sent data
// if (!fOwner)
// {
// if (static_cast<FairMQMessageSHM*>(msg.get())->fOwner)
// {
// string* ownerID = new string(fDeviceID + "o" + to_string(fMessageID));
// bool success = false;
// do
// {
// try
// {
// fOwner = Manager::Instance().Segment()->construct<ShPtrOwner>(ownerID->c_str())(*(static_cast<FairMQMessageSHM*>(msg.get())->fOwner));
// success = true;
// }
// catch (bipc::bad_alloc& ba)
// {
// LOG(WARN) << "Shared memory full...";
// this_thread::sleep_for(chrono::milliseconds(10));
// if (fInterrupted)
// {
// break;
// }
// else
// {
// continue;
// }
// }
// }
// while (!success);
// if (zmq_msg_init_data(&fMessage, const_cast<char*>(ownerID->c_str()), ownerID->length(), StringDeleter, ownerID) != 0)
// {
// LOG(ERROR) << "failed initializing meta message, reason: " << zmq_strerror(errno);
// }
// ++fMessageID;
// }
// else
// {
// LOG(ERROR) << "FairMQMessageSHM::Copy() fail: source message not initialized!";
// }
// }
// else
// {
// LOG(ERROR) << "FairMQMessageSHM::Copy() fail: target message already initialized!";
// }
}
void FairMQMessageSHM::CloseMessage()
{
// if (fReceiving)
// {
// if (fOwner)
// {
// Manager::Instance().Segment()->destroy_ptr(fOwner);
// fOwner = nullptr;
// }
// else
// {
// LOG(ERROR) << "No shared pointer owner when closing a received message";
// }
// }
// else
// {
if (fHandle && !fQueued && fRegionId == 0)
{
// LOG(WARN) << "Destroying unsent message";
// Manager::Instance().Segment()->destroy_ptr(fHandle);
Manager::Instance().Segment()->deallocate(Manager::Instance().Segment()->get_address_from_handle(fHandle));
fHandle = 0;
}
// }
if (fHandle && !fQueued && fRegionId == 0)
{
Manager::Instance().Segment()->deallocate(Manager::Instance().Segment()->get_address_from_handle(fHandle));
fHandle = 0;
}
if (fMetaCreated)
{

17
fairmq/shmem/FairMQMessageSHM.h
View File

@@ -1,8 +1,8 @@
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
#ifndef FAIRMQMESSAGESHM_H_
@@ -14,11 +14,10 @@
#include <zmq.h>
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include "FairMQMessage.h"
#include "FairMQRegion.h"
#include "FairMQUnmanagedRegion.h"
#include "FairMQShmManager.h"
class FairMQMessageSHM : public FairMQMessage
@@ -29,7 +28,7 @@ class FairMQMessageSHM : public FairMQMessage
FairMQMessageSHM();
FairMQMessageSHM(const size_t size);
FairMQMessageSHM(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr);
FairMQMessageSHM(FairMQRegionPtr& region, void* data, const size_t size);
FairMQMessageSHM(FairMQUnmanagedRegionPtr& region, void* data, const size_t size);
FairMQMessageSHM(const FairMQMessageSHM&) = delete;
FairMQMessageSHM operator=(const FairMQMessageSHM&) = delete;
@@ -56,14 +55,8 @@ class FairMQMessageSHM : public FairMQMessage
virtual ~FairMQMessageSHM();
// static void StringDeleter(void* data, void* str);
private:
zmq_msg_t fMessage;
// FairMQ::shmem::ShPtrOwner* fOwner;
// static uint64_t fMessageID;
// static std::string fDeviceID;
// bool fReceiving;
bool fQueued;
bool fMetaCreated;
static std::atomic<bool> fInterrupted;
@@ -72,7 +65,7 @@ class FairMQMessageSHM : public FairMQMessage
bipc::managed_shared_memory::handle_t fHandle;
size_t fSize;
void* fLocalPtr;
FairMQRegionPtr fRemoteRegion;
boost::interprocess::mapped_region* fRemoteRegion; // cache region ptr
};
#endif /* FAIRMQMESSAGESHM_H_ */

46
fairmq/shmem/FairMQRegionSHM.h
View File

@@ -1,46 +0,0 @@
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
#ifndef FAIRMQREGIONSHM_H_
#define FAIRMQREGIONSHM_H_
#include "FairMQRegion.h"
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <cstddef> // size_t
#include <atomic>
#include <memory>
#include <string>
class FairMQRegionSHM : public FairMQRegion
{
friend class FairMQSocketSHM;
friend class FairMQMessageSHM;
public:
FairMQRegionSHM(const size_t size);
virtual void* GetData() const override;
virtual size_t GetSize() const override;
virtual ~FairMQRegionSHM();
private:
FairMQRegionSHM(const uint64_t id, bool remote);
static std::atomic<bool> fInterrupted;
std::unique_ptr<boost::interprocess::shared_memory_object> fShmemObject;
std::unique_ptr<boost::interprocess::mapped_region> fRegion;
uint64_t fRegionId;
std::string fRegionIdStr;
bool fRemote;
};
#endif /* FAIRMQREGIONSHM_H_ */

26
fairmq/shmem/FairMQSocketSHM.cxx
View File

@@ -11,7 +11,7 @@
#include "FairMQSocketSHM.h"
#include "FairMQMessageSHM.h"
#include "FairMQRegionSHM.h"
#include "FairMQUnmanagedRegionSHM.h"
#include "FairMQLogger.h"
#include "FairMQShmCommon.h"
@@ -121,7 +121,6 @@ int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int flags)
}
else if (nbytes > 0)
{
// static_cast<FairMQMessageSHM*>(msg.get())->fReceiving = false;
static_cast<FairMQMessageSHM*>(msg.get())->fQueued = true;
size_t size = msg->GetSize();
@@ -171,26 +170,17 @@ int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int flags)
}
else if (nbytes > 0)
{
// string ownerID(static_cast<char*>(zmq_msg_data(msgPtr)), zmq_msg_size(msgPtr));
// ShPtrOwner* owner = Manager::Instance().Segment()->find<ShPtrOwner>(ownerID.c_str()).first;
MetaHeader* hdr = static_cast<MetaHeader*>(zmq_msg_data(msgPtr));
size_t size = 0;
static_cast<FairMQMessageSHM*>(msg.get())->fHandle = hdr->fHandle;
static_cast<FairMQMessageSHM*>(msg.get())->fSize = hdr->fSize;
static_cast<FairMQMessageSHM*>(msg.get())->fRegionId = hdr->fRegionId;
// static_cast<FairMQMessageSHM*>(msg.get())->fOwner = owner;
// static_cast<FairMQMessageSHM*>(msg.get())->fReceiving = true;
size = msg->GetSize();
fBytesRx += size;
++fMessagesRx;
return size;
// else
// {
// LOG(ERROR) << "Received meta data, but could not find corresponding chunk";
// return -1;
// }
}
else if (zmq_errno() == EAGAIN)
{
@@ -237,7 +227,6 @@ int64_t FairMQSocketSHM::Send(vector<FairMQMessagePtr>& msgVec, const int flags)
if (nbytes >= 0)
{
static_cast<FairMQMessageSHM*>(msgVec[i].get())->fQueued = true;
// static_cast<FairMQMessageSHM*>(msgVec[i].get())->fReceiving = false;
size_t size = msgVec[i]->GetSize();
totalSize += size;
@@ -322,25 +311,16 @@ int64_t FairMQSocketSHM::Receive(vector<FairMQMessagePtr>& msgVec, const int fla
}
else if (nbytes > 0)
{
// string ownerID(static_cast<char*>(zmq_msg_data(msgPtr)), zmq_msg_size(msgPtr));
// ShPtrOwner* owner = Manager::Instance().Segment()->find<ShPtrOwner>(ownerID.c_str()).first;
MetaHeader* hdr = static_cast<MetaHeader*>(zmq_msg_data(msgPtr));
size_t size = 0;
static_cast<FairMQMessageSHM*>(part.get())->fHandle = hdr->fHandle;
static_cast<FairMQMessageSHM*>(part.get())->fSize = hdr->fSize;
static_cast<FairMQMessageSHM*>(part.get())->fRegionId = hdr->fRegionId;
// static_cast<FairMQMessageSHM*>(part.get())->fOwner = owner;
// static_cast<FairMQMessageSHM*>(part.get())->fReceiving = true;
size = part->GetSize();
msgVec.push_back(move(part));
totalSize += size;
// else
// {
// LOG(ERROR) << "Received meta data, but could not find corresponding chunk";
// return -1;
// }
}
else if (zmq_errno() == EAGAIN)
{
@@ -396,14 +376,14 @@ void FairMQSocketSHM::Close()
void FairMQSocketSHM::Interrupt()
{
FairMQMessageSHM::fInterrupted = true;
FairMQRegionSHM::fInterrupted = true;
FairMQUnmanagedRegionSHM::fInterrupted = true;
fInterrupted = true;
}
void FairMQSocketSHM::Resume()
{
FairMQMessageSHM::fInterrupted = false;
FairMQRegionSHM::fInterrupted = true;
FairMQUnmanagedRegionSHM::fInterrupted = true;
fInterrupted = false;
}

6
fairmq/shmem/FairMQTransportFactorySHM.cxx
View File

@@ -200,7 +200,7 @@ FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(void* data, const size
return unique_ptr<FairMQMessage>(new FairMQMessageSHM(data, size, ffn, hint));
}
FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(FairMQRegionPtr& region, void* data, const size_t size) const
FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size) const
{
return unique_ptr<FairMQMessage>(new FairMQMessageSHM(region, data, size));
}
@@ -231,9 +231,9 @@ FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const FairMQSocket& cmdS
return unique_ptr<FairMQPoller>(new FairMQPollerSHM(cmdSocket, dataSocket));
}
FairMQRegionPtr FairMQTransportFactorySHM::CreateRegion(const size_t size) const
FairMQUnmanagedRegionPtr FairMQTransportFactorySHM::CreateUnmanagedRegion(const size_t size) const
{
return unique_ptr<FairMQRegion>(new FairMQRegionSHM(size));
return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionSHM(size));
}
FairMQTransportFactorySHM::~FairMQTransportFactorySHM()

6
fairmq/shmem/FairMQTransportFactorySHM.h
View File

@@ -15,7 +15,7 @@
#include "FairMQPollerSHM.h"
#include "FairMQShmCommon.h"
#include <options/FairMQProgOptions.h>
#include "FairMQRegionSHM.h"
#include "FairMQUnmanagedRegionSHM.h"
#include <vector>
#include <string>
@@ -34,7 +34,7 @@ class FairMQTransportFactorySHM : public FairMQTransportFactory
FairMQMessagePtr CreateMessage() const override;
FairMQMessagePtr CreateMessage(const size_t size) const override;
FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const override;
FairMQMessagePtr CreateMessage(FairMQRegionPtr& region, void* data, const size_t size) const override;
FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size) const override;
FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) const override;
@@ -43,7 +43,7 @@ class FairMQTransportFactorySHM : public FairMQTransportFactory
FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override;
FairMQPollerPtr CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const override;
FairMQRegionPtr CreateRegion(const size_t size) const override;
FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size) const override;
FairMQ::Transport GetType() const override;

76
fairmq/shmem/FairMQRegionSHM.cxx → fairmq/shmem/FairMQUnmanagedRegionSHM.cxx
View File

@@ -6,7 +6,7 @@
* copied verbatim in the file "LICENSE" *
********************************************************************************/
#include "FairMQRegionSHM.h"
#include "FairMQUnmanagedRegionSHM.h"
#include "FairMQShmManager.h"
#include "FairMQShmCommon.h"
@@ -15,11 +15,11 @@ using namespace fair::mq::shmem;
namespace bipc = boost::interprocess;
atomic<bool> FairMQRegionSHM::fInterrupted(false);
atomic<bool> FairMQUnmanagedRegionSHM::fInterrupted(false);
unordered_map<uint64_t, RemoteRegion> FairMQUnmanagedRegionSHM::fRemoteRegionMap;
FairMQRegionSHM::FairMQRegionSHM(const size_t size)
: fShmemObject()
, fRegion()
FairMQUnmanagedRegionSHM::FairMQUnmanagedRegionSHM(const size_t size)
: fRegion(nullptr)
, fRegionId(0)
, fRegionIdStr()
, fRemote(false)
@@ -41,11 +41,24 @@ FairMQRegionSHM::FairMQRegionSHM(const size_t size)
}
fRegionId = rc->fCount;
fRegionIdStr = "fairmq_shmem_region_" + std::to_string(fRegionId);
fRegionIdStr = "fairmq_shmem_region_" + to_string(fRegionId);
fShmemObject = unique_ptr<bipc::shared_memory_object>(new bipc::shared_memory_object(bipc::create_only, fRegionIdStr.c_str(), bipc::read_write));
fShmemObject->truncate(size);
fRegion = unique_ptr<bipc::mapped_region>(new bipc::mapped_region(*fShmemObject, bipc::read_write)); // TODO: add HUGEPAGES flag here
auto it = fRemoteRegionMap.find(fRegionId);
if (it != fRemoteRegionMap.end())
{
LOG(ERROR) << "Trying to create a region that already exists";
}
else
{
string regionIdStr = "fairmq_shmem_region_" + to_string(fRegionId);
LOG(DEBUG) << "creating region with id " << fRegionId;
auto r = fRemoteRegionMap.emplace(fRegionId, RemoteRegion{regionIdStr, size});
fRegion = &(r.first->second.fRegion);
LOG(DEBUG) << "created region with id " << fRegionId;
}
}
catch (bipc::interprocess_exception& e)
{
@@ -55,43 +68,32 @@ FairMQRegionSHM::FairMQRegionSHM(const size_t size)
}
}
FairMQRegionSHM::FairMQRegionSHM(const uint64_t id, bool remote)
: fShmemObject()
, fRegion()
, fRegionId(id)
, fRegionIdStr()
, fRemote(remote)
{
try
{
fRegionIdStr = "fairmq_shmem_region_" + std::to_string(fRegionId);
fShmemObject = unique_ptr<bipc::shared_memory_object>(new bipc::shared_memory_object(bipc::open_only, fRegionIdStr.c_str(), bipc::read_write));
fRegion = unique_ptr<bipc::mapped_region>(new bipc::mapped_region(*fShmemObject, bipc::read_write)); // TODO: add HUGEPAGES flag here
}
catch (bipc::interprocess_exception& e)
{
LOG(ERROR) << "shmem: cannot open region. Already closed?";
LOG(ERROR) << e.what();
exit(EXIT_FAILURE);
}
}
void* FairMQRegionSHM::GetData() const
void* FairMQUnmanagedRegionSHM::GetData() const
{
return fRegion->get_address();
}
size_t FairMQRegionSHM::GetSize() const
size_t FairMQUnmanagedRegionSHM::GetSize() const
{
return fRegion->get_size();
}
FairMQRegionSHM::~FairMQRegionSHM()
bipc::mapped_region* FairMQUnmanagedRegionSHM::GetRemoteRegion(uint64_t regionId)
{
if (!fRemote)
auto it = fRemoteRegionMap.find(regionId);
if (it != fRemoteRegionMap.end())
{
LOG(DEBUG) << "destroying region";
bipc::shared_memory_object::remove(fRegionIdStr.c_str());
return &(it->second.fRegion);
}
else
{
string regionIdStr = "fairmq_shmem_region_" + to_string(regionId);
auto r = fRemoteRegionMap.emplace(regionId, RemoteRegion{regionIdStr, 0});
return &(r.first->second.fRegion);
}
}
FairMQUnmanagedRegionSHM::~FairMQUnmanagedRegionSHM()
{
}

79
fairmq/shmem/FairMQUnmanagedRegionSHM.h Normal file
View File

@@ -0,0 +1,79 @@
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
#ifndef FAIRMQUNMANAGEDREGIONSHM_H_
#define FAIRMQUNMANAGEDREGIONSHM_H_
#include "FairMQUnmanagedRegion.h"
#include "FairMQLogger.h"
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <cstddef> // size_t
#include <atomic>
#include <memory>
#include <string>
#include <unordered_map>
struct RemoteRegion // todo: better name?
{
RemoteRegion(std::string regionIdStr, uint64_t size)
: fRegionName(regionIdStr)
, fShmemObject(boost::interprocess::open_or_create, regionIdStr.c_str(), boost::interprocess::read_write)
{
if (size > 0)
{
fShmemObject.truncate(size);
}
fRegion = boost::interprocess::mapped_region(fShmemObject, boost::interprocess::read_write); // TODO: add HUGEPAGES flag here
}
RemoteRegion() = delete;
RemoteRegion(const RemoteRegion& rr) = default;
RemoteRegion(RemoteRegion&& rr) = default;
~RemoteRegion()
{
if (boost::interprocess::shared_memory_object::remove(fRegionName.c_str()))
{
LOG(DEBUG) << "destroyed region " << fRegionName;
}
}
std::string fRegionName;
boost::interprocess::shared_memory_object fShmemObject;
boost::interprocess::mapped_region fRegion;
};
class FairMQUnmanagedRegionSHM : public FairMQUnmanagedRegion
{
friend class FairMQSocketSHM;
friend class FairMQMessageSHM;
public:
FairMQUnmanagedRegionSHM(const size_t size);
virtual void* GetData() const override;
virtual size_t GetSize() const override;
static boost::interprocess::mapped_region* GetRemoteRegion(uint64_t regionId);
virtual ~FairMQUnmanagedRegionSHM();
private:
static std::atomic<bool> fInterrupted;
boost::interprocess::mapped_region* fRegion;
uint64_t fRegionId;
std::string fRegionIdStr;
bool fRemote;
static std::unordered_map<uint64_t, RemoteRegion> fRemoteRegionMap;
};
#endif /* FAIRMQUNMANAGEDREGIONSHM_H_ */