FairMQ: Introduce callbacks for the FairMQUnmanagedRegion.

Callbacks are called when the data buffer of the message assiciated
with the corresponding region is no longer needed by the transport.
Example in examples/advanced/Region/

fairmq/nanomsg/FairMQMessageNN.cxx

@@ -22,14 +22,13 @@
 
 using namespace std;
 
-string FairMQMessageNN::fDeviceID = string();
 FairMQ::Transport FairMQMessageNN::fTransportType = FairMQ::Transport::NN;
 
 FairMQMessageNN::FairMQMessageNN()
     : fMessage(nullptr)
     , fSize(0)
     , fReceiving(false)
-    , fRegion(false)
+    , fRegionPtr(nullptr)
 {
     fMessage = nn_allocmsg(0, 0);
     if (!fMessage)
@@ -42,7 +41,7 @@ FairMQMessageNN::FairMQMessageNN(const size_t size)
     : fMessage(nullptr)
     , fSize(0)
     , fReceiving(false)
-    , fRegion(false)
+    , fRegionPtr(nullptr)
 {
     fMessage = nn_allocmsg(size, 0);
     if (!fMessage)
@@ -62,7 +61,7 @@ FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn*
     : fMessage(nullptr)
     , fSize(0)
     , fReceiving(false)
-    , fRegion(false)
+    , fRegionPtr(nullptr)
 {
     fMessage = nn_allocmsg(size, 0);
     if (!fMessage)
@@ -84,11 +83,11 @@ FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn*
     }
 }
 
-FairMQMessageNN::FairMQMessageNN(FairMQUnmanagedRegionPtr& /*region*/, void* data, const size_t size)
+FairMQMessageNN::FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size)
     : fMessage(data)
     , fSize(size)
     , fReceiving(false)
-    , fRegion(true)
+    , fRegionPtr(region.get())
 {
     // currently nanomsg will copy the buffer (data) inside nn_sendmsg()
 }
@@ -153,11 +152,6 @@ void FairMQMessageNN::SetMessage(void* data, const size_t size)
     fSize = size;
 }
 
-void FairMQMessageNN::SetDeviceId(const string& deviceId)
-{
-    fDeviceID = deviceId;
-}
-
 FairMQ::Transport FairMQMessageNN::GetType() const
 {
     return fTransportType;

fairmq/nanomsg/FairMQMessageNN.h

@@ -17,6 +17,7 @@
 
 #include <cstddef>
 #include <string>
+#include <memory>
 
 #include "FairMQMessage.h"
 #include "FairMQUnmanagedRegion.h"
@@ -42,8 +43,6 @@ class FairMQMessageNN : public FairMQMessage
 
     virtual void SetMessage(void* data, const size_t size);
 
-    virtual void SetDeviceId(const std::string& deviceId);
-
     virtual FairMQ::Transport GetType() const;
 
     virtual void Copy(const std::unique_ptr<FairMQMessage>& msg);
@@ -56,8 +55,7 @@ class FairMQMessageNN : public FairMQMessage
     void* fMessage;
     size_t fSize;
     bool fReceiving;
-    bool fRegion;
-    static std::string fDeviceID;
+    FairMQUnmanagedRegion* fRegionPtr;
     static FairMQ::Transport fTransportType;
 
     void Clear();

fairmq/nanomsg/FairMQSocketNN.cxx

@@ -15,6 +15,7 @@
 #include "FairMQSocketNN.h"
 #include "FairMQMessageNN.h"
 #include "FairMQLogger.h"
+#include "FairMQUnmanagedRegionNN.h"
 
 #include <nanomsg/nn.h>
 #include <nanomsg/pipeline.h>
@@ -127,14 +128,17 @@ int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int flags)
     while (true)
     {
         void* ptr = msg->GetMessage();
-        if (static_cast<FairMQMessageNN*>(msg.get())->fRegion == false)
+        if (static_cast<FairMQMessageNN*>(msg.get())->fRegionPtr == nullptr)
         {
             nbytes = nn_send(fSocket, &ptr, NN_MSG, flags);
         }
         else
         {
             nbytes = nn_send(fSocket, ptr, msg->GetSize(), flags);
+            // nn_send copies the data, safe to call region callback here
+            static_cast<FairMQUnmanagedRegionNN*>(static_cast<FairMQMessageNN*>(msg.get())->fRegionPtr)->fCallback(msg->GetMessage(), msg->GetSize());
         }
+
         if (nbytes >= 0)
         {
             fBytesTx += nbytes;
@@ -239,6 +243,8 @@ int64_t FairMQSocketNN::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const in
         static_cast<FairMQMessageNN*>(msgVec[i].get())->fReceiving = false;
         packer.pack_bin(msgVec[i]->GetSize());
         packer.pack_bin_body(static_cast<char*>(msgVec[i]->GetData()), msgVec[i]->GetSize());
+        // call region callback
+        static_cast<FairMQUnmanagedRegionNN*>(static_cast<FairMQMessageNN*>(msgVec[i].get())->fRegionPtr)->fCallback(msgVec[i]->GetMessage(), msgVec[i]->GetSize());
     }
 
     int64_t nbytes = -1;

fairmq/nanomsg/FairMQTransportFactoryNN.cxx

@@ -65,9 +65,9 @@ FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const FairMQSocket& cmdSo
     return unique_ptr<FairMQPoller>(new FairMQPollerNN(cmdSocket, dataSocket));
 }
 
-FairMQUnmanagedRegionPtr FairMQTransportFactoryNN::CreateUnmanagedRegion(const size_t size) const
+FairMQUnmanagedRegionPtr FairMQTransportFactoryNN::CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const
 {
-    return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionNN(size));
+    return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionNN(size, callback));
 }
 
 FairMQ::Transport FairMQTransportFactoryNN::GetType() const

fairmq/nanomsg/FairMQTransportFactoryNN.h

@@ -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;
 
-    FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size) const override;
+    FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const override;
 
     FairMQ::Transport GetType() const override;
 

fairmq/nanomsg/FairMQUnmanagedRegionNN.cxx

@@ -11,9 +11,10 @@
 
 using namespace std;
 
-FairMQUnmanagedRegionNN::FairMQUnmanagedRegionNN(const size_t size)
+FairMQUnmanagedRegionNN::FairMQUnmanagedRegionNN(const size_t size, FairMQRegionCallback callback)
     : fBuffer(malloc(size))
     , fSize(size)
+    , fCallback(callback)
 {
 }
 

fairmq/nanomsg/FairMQUnmanagedRegionNN.h

@@ -18,7 +18,7 @@ class FairMQUnmanagedRegionNN : public FairMQUnmanagedRegion
     friend class FairMQSocketNN;
 
   public:
-    FairMQUnmanagedRegionNN(const size_t size);
+    FairMQUnmanagedRegionNN(const size_t size, FairMQRegionCallback callback);
     FairMQUnmanagedRegionNN(const FairMQUnmanagedRegionNN&) = delete;
     FairMQUnmanagedRegionNN operator=(const FairMQUnmanagedRegionNN&) = delete;
 
@@ -30,6 +30,7 @@ class FairMQUnmanagedRegionNN : public FairMQUnmanagedRegion
   private:
     void* fBuffer;
     size_t fSize;
+    FairMQRegionCallback fCallback;
 };
 
 #endif /* FAIRMQUNMANAGEDREGIONNN_H_ */