FairMQ: shared memory unmanaged region updates:

- use same mapping for sender/receiver (created/remote) region.
 - rename FairMQRegion -> FairMQUnmanagedRegion.

fairmq/CMakeLists.txt

@@ -72,7 +72,7 @@ set(FAIRMQ_HEADER_FILES
     FairMQMessage.h
     FairMQParts.h
     FairMQPoller.h
-    FairMQRegion.h
+    FairMQUnmanagedRegion.h
     FairMQSocket.h
     FairMQStateMachine.h
     FairMQTransportFactory.h
@@ -99,7 +99,7 @@ set(FAIRMQ_HEADER_FILES
     StateMachine.h
     shmem/FairMQMessageSHM.h
     shmem/FairMQPollerSHM.h
-    shmem/FairMQRegionSHM.h
+    shmem/FairMQUnmanagedRegionSHM.h
     shmem/FairMQSocketSHM.h
     shmem/FairMQTransportFactorySHM.h
     shmem/FairMQShmMonitor.h
@@ -110,7 +110,7 @@ set(FAIRMQ_HEADER_FILES
     tools/Version.h
     zeromq/FairMQMessageZMQ.h
     zeromq/FairMQPollerZMQ.h
-    zeromq/FairMQRegionZMQ.h
+    zeromq/FairMQUnmanagedRegionZMQ.h
     zeromq/FairMQSocketZMQ.h
     zeromq/FairMQTransportFactoryZMQ.h
 )
@@ -119,7 +119,7 @@ if(NANOMSG_FOUND)
     set(FAIRMQ_HEADER_FILES ${FAIRMQ_HEADER_FILES}
         nanomsg/FairMQMessageNN.h
         nanomsg/FairMQPollerNN.h
-        nanomsg/FairMQRegionNN.h
+        nanomsg/FairMQUnmanagedRegionNN.h
         nanomsg/FairMQSocketNN.h
         nanomsg/FairMQTransportFactoryNN.h
     )
@@ -160,13 +160,13 @@ set(FAIRMQ_SOURCE_FILES
     StateMachine.cxx
     shmem/FairMQMessageSHM.cxx
     shmem/FairMQPollerSHM.cxx
-    shmem/FairMQRegionSHM.cxx
+    shmem/FairMQUnmanagedRegionSHM.cxx
     shmem/FairMQSocketSHM.cxx
     shmem/FairMQTransportFactorySHM.cxx
     shmem/FairMQShmMonitor.cxx
     zeromq/FairMQMessageZMQ.cxx
     zeromq/FairMQPollerZMQ.cxx
-    zeromq/FairMQRegionZMQ.cxx
+    zeromq/FairMQUnmanagedRegionZMQ.cxx
     zeromq/FairMQSocketZMQ.cxx
     zeromq/FairMQTransportFactoryZMQ.cxx
 )
@@ -175,7 +175,7 @@ if(NANOMSG_FOUND)
     set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
         nanomsg/FairMQMessageNN.cxx
         nanomsg/FairMQPollerNN.cxx
-        nanomsg/FairMQRegionNN.cxx
+        nanomsg/FairMQUnmanagedRegionNN.cxx
         nanomsg/FairMQSocketNN.cxx
         nanomsg/FairMQTransportFactoryNN.cxx
     )

fairmq/FairMQDevice.h

@@ -17,7 +17,7 @@
 #include "FairMQChannel.h"
 #include "FairMQMessage.h"
 #include "FairMQParts.h"
-#include "FairMQRegion.h"
+#include "FairMQUnmanagedRegion.h"
 
 #include <vector>
 #include <memory> // unique_ptr
@@ -235,14 +235,14 @@ class FairMQDevice : public FairMQStateMachine
         return fChannels.at(channel).at(index).NewSimpleMessage(data);
     }
 
-    FairMQRegionPtr NewRegion(const size_t size)
+    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size)
     {
-        return Transport()->CreateRegion(size);
+        return Transport()->CreateUnmanagedRegion(size);
     }
 
-    FairMQRegionPtr NewRegionFor(const std::string& channel, int index, const size_t size)
+    FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel, int index, const size_t size)
     {
-        return fChannels.at(channel).at(index).Transport()->CreateRegion(size);
+        return fChannels.at(channel).at(index).Transport()->CreateUnmanagedRegion(size);
     }
 
     template<typename ...Ts>

fairmq/FairMQTransportFactory.h

@@ -12,9 +12,10 @@
 #include "FairMQMessage.h"
 #include "FairMQSocket.h"
 #include "FairMQPoller.h"
-#include "FairMQRegion.h"
+#include "FairMQUnmanagedRegion.h"
 #include "FairMQLogger.h"
 #include "FairMQTransports.h"
+
 #include <string>
 #include <memory>
 #include <vector>
@@ -51,7 +52,7 @@ class FairMQTransportFactory
     /// @return pointer to FairMQMessage
     virtual FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const = 0;
 
-    virtual FairMQMessagePtr CreateMessage(FairMQRegionPtr& region, void* data, const size_t size) const = 0;
+    virtual FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& unmanagedRegion, void* data, const size_t size) const = 0;
 
     /// Create a socket
     virtual FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) const = 0;
@@ -65,7 +66,7 @@ class FairMQTransportFactory
     /// Create a poller for two sockets
     virtual FairMQPollerPtr CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const = 0;
 
-    virtual FairMQRegionPtr CreateRegion(const size_t size) const = 0;
+    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size) const = 0;
 
     /// Get transport type
     virtual FairMQ::Transport GetType() const = 0;

fairmq/FairMQUnmanagedRegion.h

@@ -6,21 +6,21 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#ifndef FAIRMQREGION_H_
+#ifndef FAIRMQUNMANAGEDREGION_H_
-#define FAIRMQREGION_H_
+#define FAIRMQUNMANAGEDREGION_H_
 
 #include <cstddef> // size_t
 #include <memory> // unique_ptr
 
-class FairMQRegion
+class FairMQUnmanagedRegion
 {
   public:
     virtual void* GetData() const = 0;
     virtual size_t GetSize() const = 0;
 
-    virtual ~FairMQRegion() {};
+    virtual ~FairMQUnmanagedRegion() {};
 };
 
-using FairMQRegionPtr = std::unique_ptr<FairMQRegion>;
+using FairMQUnmanagedRegionPtr = std::unique_ptr<FairMQUnmanagedRegion>;
 
-#endif /* FAIRMQREGION_H_ */
+#endif /* FAIRMQUNMANAGEDREGION_H_ */

fairmq/nanomsg/FairMQMessageNN.cxx

@@ -84,7 +84,7 @@ FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn*
     }
 }
 
-FairMQMessageNN::FairMQMessageNN(FairMQRegionPtr& /*region*/, void* data, const size_t size)
+FairMQMessageNN::FairMQMessageNN(FairMQUnmanagedRegionPtr& /*region*/, void* data, const size_t size)
     : fMessage(data)
     , fSize(size)
     , fReceiving(false)

fairmq/nanomsg/FairMQMessageNN.h

@@ -19,7 +19,7 @@
 #include <string>
 
 #include "FairMQMessage.h"
-#include "FairMQRegion.h"
+#include "FairMQUnmanagedRegion.h"
 
 class FairMQMessageNN : public FairMQMessage
 {
@@ -27,7 +27,7 @@ class FairMQMessageNN : public FairMQMessage
     FairMQMessageNN();
     FairMQMessageNN(const size_t size);
     FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr);
-    FairMQMessageNN(FairMQRegionPtr& region, void* data, const size_t size);
+    FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size);
 
     FairMQMessageNN(const FairMQMessageNN&) = delete;
     FairMQMessageNN operator=(const FairMQMessageNN&) = delete;

fairmq/nanomsg/FairMQTransportFactoryNN.cxx

@@ -35,7 +35,7 @@ FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(void* data, const size_
     return unique_ptr<FairMQMessage>(new FairMQMessageNN(data, size, ffn, hint));
 }
 
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(FairMQRegionPtr& region, void* data, const size_t size) const
+FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size) const
 {
     return unique_ptr<FairMQMessage>(new FairMQMessageNN(region, data, size));
 }
@@ -65,9 +65,9 @@ FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const FairMQSocket& cmdSo
     return unique_ptr<FairMQPoller>(new FairMQPollerNN(cmdSocket, dataSocket));
 }
 
-FairMQRegionPtr FairMQTransportFactoryNN::CreateRegion(const size_t size) const
+FairMQUnmanagedRegionPtr FairMQTransportFactoryNN::CreateUnmanagedRegion(const size_t size) const
 {
-    return unique_ptr<FairMQRegion>(new FairMQRegionNN(size));
+    return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionNN(size));
 }
 
 FairMQ::Transport FairMQTransportFactoryNN::GetType() const

fairmq/nanomsg/FairMQTransportFactoryNN.h

@@ -13,7 +13,7 @@
 #include "FairMQMessageNN.h"
 #include "FairMQSocketNN.h"
 #include "FairMQPollerNN.h"
-#include "FairMQRegionNN.h"
+#include "FairMQUnmanagedRegionNN.h"
 #include <options/FairMQProgOptions.h>
 
 #include <vector>
@@ -28,7 +28,7 @@ class FairMQTransportFactoryNN : 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;
 
@@ -37,7 +37,7 @@ class FairMQTransportFactoryNN : 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;
 

fairmq/nanomsg/FairMQUnmanagedRegionNN.cxx

@@ -6,28 +6,28 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include "FairMQRegionNN.h"
+#include "FairMQUnmanagedRegionNN.h"
 #include "FairMQLogger.h"
 
 using namespace std;
 
-FairMQRegionNN::FairMQRegionNN(const size_t size)
+FairMQUnmanagedRegionNN::FairMQUnmanagedRegionNN(const size_t size)
     : fBuffer(malloc(size))
     , fSize(size)
 {
 }
 
-void* FairMQRegionNN::GetData() const
+void* FairMQUnmanagedRegionNN::GetData() const
 {
     return fBuffer;
 }
 
-size_t FairMQRegionNN::GetSize() const
+size_t FairMQUnmanagedRegionNN::GetSize() const
 {
     return fSize;
 }
 
-FairMQRegionNN::~FairMQRegionNN()
+FairMQUnmanagedRegionNN::~FairMQUnmanagedRegionNN()
 {
     LOG(DEBUG) << "destroying region";
     free(fBuffer);

fairmq/nanomsg/FairMQUnmanagedRegionNN.h

@@ -6,30 +6,30 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#ifndef FAIRMQREGIONNN_H_
+#ifndef FAIRMQUNMANAGEDREGIONNN_H_
-#define FAIRMQREGIONNN_H_
+#define FAIRMQUNMANAGEDREGIONNN_H_
 
-#include "FairMQRegion.h"
+#include "FairMQUnmanagedRegion.h"
 
 #include <cstddef> // size_t
 
-class FairMQRegionNN : public FairMQRegion
+class FairMQUnmanagedRegionNN : public FairMQUnmanagedRegion
 {
     friend class FairMQSocketNN;
 
   public:
-    FairMQRegionNN(const size_t size);
+    FairMQUnmanagedRegionNN(const size_t size);
-    FairMQRegionNN(const FairMQRegionNN&) = delete;
+    FairMQUnmanagedRegionNN(const FairMQUnmanagedRegionNN&) = delete;
-    FairMQRegionNN operator=(const FairMQRegionNN&) = delete;
+    FairMQUnmanagedRegionNN operator=(const FairMQUnmanagedRegionNN&) = delete;
 
     virtual void* GetData() const override;
     virtual size_t GetSize() const override;
 
-    virtual ~FairMQRegionNN();
+    virtual ~FairMQUnmanagedRegionNN();
 
   private:
     void* fBuffer;
     size_t fSize;
 };
 
-#endif /* FAIRMQREGIONNN_H_ */
+#endif /* FAIRMQUNMANAGEDREGIONNN_H_ */

fairmq/shmem/FairMQMessageSHM.cxx

@@ -1,15 +1,15 @@
 /********************************************************************************
  *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
  *                                                                              *
- *              This software is distributed under the terms of the             * 
+ *              This software is distributed under the terms of the             *
- *         GNU Lesser General Public Licence version 3 (LGPL) version 3,        *  
+ *         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 (fHandle && !fQueued && fRegionId == 0)
-    // {
+    {
-    //     if (fOwner)
+        Manager::Instance().Segment()->deallocate(Manager::Instance().Segment()->get_address_from_handle(fHandle));
-    //     {
+        fHandle = 0;
-    //         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 (fMetaCreated)
     {

fairmq/shmem/FairMQMessageSHM.h

@@ -1,8 +1,8 @@
 /********************************************************************************
  *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
  *                                                                              *
- *              This software is distributed under the terms of the             * 
+ *              This software is distributed under the terms of the             *
- *         GNU Lesser General Public Licence version 3 (LGPL) version 3,        *  
+ *         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_ */

fairmq/shmem/FairMQRegionSHM.h

@@ -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_ */

fairmq/shmem/FairMQSocketSHM.cxx

@@ -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;
 }
 

fairmq/shmem/FairMQTransportFactorySHM.cxx

@@ -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()

fairmq/shmem/FairMQTransportFactorySHM.h

@@ -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;
 

fairmq/shmem/FairMQUnmanagedRegionSHM.cxx

@@ -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)
+FairMQUnmanagedRegionSHM::FairMQUnmanagedRegionSHM(const size_t size)
-    : fShmemObject()
+    : fRegion(nullptr)
-    , fRegion()
     , 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));
+        auto it = fRemoteRegionMap.find(fRegionId);
-        fShmemObject->truncate(size);
+        if (it != fRemoteRegionMap.end())
-        fRegion = unique_ptr<bipc::mapped_region>(new bipc::mapped_region(*fShmemObject, bipc::read_write)); // TODO: add HUGEPAGES flag here
+        {
+            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)
+void* FairMQUnmanagedRegionSHM::GetData() const
-    : 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
 {
     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";
+        return &(it->second.fRegion);
-        bipc::shared_memory_object::remove(fRegionIdStr.c_str());
+    }
+    else
+    {
+        string regionIdStr = "fairmq_shmem_region_" + to_string(regionId);
+
+        auto r = fRemoteRegionMap.emplace(regionId, RemoteRegion{regionIdStr, 0});
+        return &(r.first->second.fRegion);
     }
 }
+
+FairMQUnmanagedRegionSHM::~FairMQUnmanagedRegionSHM()
+{
+}

fairmq/shmem/FairMQUnmanagedRegionSHM.h

@@ -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_ */

fairmq/zeromq/FairMQMessageZMQ.cxx

@@ -50,7 +50,7 @@ FairMQMessageZMQ::FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn
     }
 }
 
-FairMQMessageZMQ::FairMQMessageZMQ(FairMQRegionPtr& /*region*/, void* data, const size_t size)
+FairMQMessageZMQ::FairMQMessageZMQ(FairMQUnmanagedRegionPtr& /*region*/, void* data, const size_t size)
     : fMessage()
 {
     // FIXME: make this zero-copy:

fairmq/zeromq/FairMQMessageZMQ.h

@@ -21,7 +21,7 @@
 #include <zmq.h>
 
 #include "FairMQMessage.h"
-#include "FairMQRegion.h"
+#include "FairMQUnmanagedRegion.h"
 
 class FairMQMessageZMQ : public FairMQMessage
 {
@@ -29,7 +29,7 @@ class FairMQMessageZMQ : public FairMQMessage
     FairMQMessageZMQ();
     FairMQMessageZMQ(const size_t size);
     FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr);
-    FairMQMessageZMQ(FairMQRegionPtr& region, void* data, const size_t size);
+    FairMQMessageZMQ(FairMQUnmanagedRegionPtr& region, void* data, const size_t size);
 
     virtual void Rebuild();
     virtual void Rebuild(const size_t size);

fairmq/zeromq/FairMQTransportFactoryZMQ.cxx

@@ -64,7 +64,7 @@ FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(void* data, const size
     return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(data, size, ffn, hint));
 }
 
-FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(FairMQRegionPtr& region, void* data, const size_t size) const
+FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size) const
 {
     return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(region, data, size));
 }
@@ -95,9 +95,9 @@ FairMQPollerPtr FairMQTransportFactoryZMQ::CreatePoller(const FairMQSocket& cmdS
     return unique_ptr<FairMQPoller>(new FairMQPollerZMQ(cmdSocket, dataSocket));
 }
 
-FairMQRegionPtr FairMQTransportFactoryZMQ::CreateRegion(const size_t size) const
+FairMQUnmanagedRegionPtr FairMQTransportFactoryZMQ::CreateUnmanagedRegion(const size_t size) const
 {
-    return unique_ptr<FairMQRegion>(new FairMQRegionZMQ(size));
+    return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionZMQ(size));
 }
 
 FairMQ::Transport FairMQTransportFactoryZMQ::GetType() const

fairmq/zeromq/FairMQTransportFactoryZMQ.h

@@ -22,7 +22,7 @@
 #include "FairMQMessageZMQ.h"
 #include "FairMQSocketZMQ.h"
 #include "FairMQPollerZMQ.h"
-#include "FairMQRegionZMQ.h"
+#include "FairMQUnmanagedRegionZMQ.h"
 #include <options/FairMQProgOptions.h>
 
 class FairMQTransportFactoryZMQ : public FairMQTransportFactory
@@ -37,7 +37,7 @@ class FairMQTransportFactoryZMQ : 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;
 
@@ -46,7 +46,7 @@ class FairMQTransportFactoryZMQ : 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;
   private:

fairmq/zeromq/FairMQUnmanagedRegionZMQ.cxx

@@ -6,28 +6,28 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include "FairMQRegionZMQ.h"
+#include "FairMQUnmanagedRegionZMQ.h"
 #include "FairMQLogger.h"
 
 using namespace std;
 
-FairMQRegionZMQ::FairMQRegionZMQ(const size_t size)
+FairMQUnmanagedRegionZMQ::FairMQUnmanagedRegionZMQ(const size_t size)
     : fBuffer(malloc(size))
     , fSize(size)
 {
 }
 
-void* FairMQRegionZMQ::GetData() const
+void* FairMQUnmanagedRegionZMQ::GetData() const
 {
     return fBuffer;
 }
 
-size_t FairMQRegionZMQ::GetSize() const
+size_t FairMQUnmanagedRegionZMQ::GetSize() const
 {
     return fSize;
 }
 
-FairMQRegionZMQ::~FairMQRegionZMQ()
+FairMQUnmanagedRegionZMQ::~FairMQUnmanagedRegionZMQ()
 {
     LOG(DEBUG) << "destroying region";
     free(fBuffer);

fairmq/zeromq/FairMQUnmanagedRegionZMQ.h

@@ -6,30 +6,30 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#ifndef FAIRMQREGIONZMQ_H_
+#ifndef FAIRMQUNMANAGEDREGIONZMQ_H_
-#define FAIRMQREGIONZMQ_H_
+#define FAIRMQUNMANAGEDREGIONZMQ_H_
 
-#include "FairMQRegion.h"
+#include "FairMQUnmanagedRegion.h"
 
 #include <cstddef> // size_t
 
-class FairMQRegionZMQ : public FairMQRegion
+class FairMQUnmanagedRegionZMQ : public FairMQUnmanagedRegion
 {
     friend class FairMQSocketSHM;
 
   public:
-    FairMQRegionZMQ(const size_t size);
+    FairMQUnmanagedRegionZMQ(const size_t size);
-    FairMQRegionZMQ(const FairMQRegionZMQ&) = delete;
+    FairMQUnmanagedRegionZMQ(const FairMQUnmanagedRegionZMQ&) = delete;
-    FairMQRegionZMQ operator=(const FairMQRegionZMQ&) = delete;
+    FairMQUnmanagedRegionZMQ operator=(const FairMQUnmanagedRegionZMQ&) = delete;
 
     virtual void* GetData() const override;
     virtual size_t GetSize() const override;
 
-    virtual ~FairMQRegionZMQ();
+    virtual ~FairMQUnmanagedRegionZMQ();
 
   private:
     void* fBuffer;
     size_t fSize;
 };
 
-#endif /* FAIRMQREGIONZMQ_H_ */
+#endif /* FAIRMQUNMANAGEDREGIONZMQ_H_ */