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

replace cmd socket with transport specific unblock mechanism

Browse Source
This commit is contained in:
Alexey Rybalchenko 2018-02-20 10:44:56 +01:00 committed by Mohammad Al-Turany
parent 209e521046
commit fed7601be4
21 changed files with 402 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
fairmq/FairMQChannel.cxx
View File

@ -23,8 +23,6 @@ using namespace std;
mutex FairMQChannel::fChannelMutex; mutex FairMQChannel::fChannelMutex;
atomic<bool> FairMQChannel::fInterrupted(false);
FairMQChannel::FairMQChannel() FairMQChannel::FairMQChannel()
: fSocket(nullptr) : fSocket(nullptr)
, fType("unspecified") , fType("unspecified")
@ -38,8 +36,6 @@ FairMQChannel::FairMQChannel()
, fRateLogging(1) , fRateLogging(1)
, fName("") , fName("")
, fIsValid(false) , fIsValid(false)
, fPoller(nullptr)
, fChannelCmdSocket(nullptr)
, fTransportType(FairMQ::Transport::DEFAULT) , fTransportType(FairMQ::Transport::DEFAULT)
, fTransportFactory(nullptr) , fTransportFactory(nullptr)
, fMultipart(false) , fMultipart(false)
@ -61,8 +57,6 @@ FairMQChannel::FairMQChannel(const string& type, const string& method, const str
, fRateLogging(1) , fRateLogging(1)
, fName("") , fName("")
, fIsValid(false) , fIsValid(false)
, fPoller(nullptr)
, fChannelCmdSocket(nullptr)
, fTransportType(FairMQ::Transport::DEFAULT) , fTransportType(FairMQ::Transport::DEFAULT)
, fTransportFactory(nullptr) , fTransportFactory(nullptr)
, fMultipart(false) , fMultipart(false)
@ -84,8 +78,6 @@ FairMQChannel::FairMQChannel(const string& name, const string& type, std::shared
, fRateLogging(1) , fRateLogging(1)
, fName(name) , fName(name)
, fIsValid(false) , fIsValid(false)
, fPoller(nullptr)
, fChannelCmdSocket(nullptr)
, fTransportType(factory->GetType()) , fTransportType(factory->GetType())
, fTransportFactory(factory) , fTransportFactory(factory)
, fMultipart(false) , fMultipart(false)
@ -107,8 +99,6 @@ FairMQChannel::FairMQChannel(const FairMQChannel& chan)
, fRateLogging(chan.fRateLogging) , fRateLogging(chan.fRateLogging)
, fName(chan.fName) , fName(chan.fName)
, fIsValid(false) , fIsValid(false)
, fPoller(nullptr)
, fChannelCmdSocket(nullptr)
, fTransportType(FairMQ::Transport::DEFAULT) , fTransportType(FairMQ::Transport::DEFAULT)
, fTransportFactory(nullptr) , fTransportFactory(nullptr)
, fMultipart(chan.fMultipart) , fMultipart(chan.fMultipart)
@ -130,8 +120,6 @@ FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
fSocket = nullptr; fSocket = nullptr;
fName = chan.fName; fName = chan.fName;
fIsValid = false; fIsValid = false;
fPoller = nullptr;
fChannelCmdSocket = nullptr;
fTransportType = FairMQ::Transport::DEFAULT; fTransportType = FairMQ::Transport::DEFAULT;
fTransportFactory = nullptr; fTransportFactory = nullptr;
@ -660,23 +648,6 @@ void FairMQChannel::InitTransport(shared_ptr<FairMQTransportFactory> factory)
fTransportType = factory->GetType(); fTransportType = factory->GetType();
} }
bool FairMQChannel::InitCommandInterface(FairMQSocketPtr channelCmdSocket)
{
fChannelCmdSocket = std::move(channelCmdSocket);
if (fChannelCmdSocket)
{
fChannelCmdSocket->Connect("inproc://commands");
fPoller = fTransportFactory->CreatePoller(*fChannelCmdSocket, *fSocket);
return true;
}
else
{
return false;
}
}
void FairMQChannel::ResetChannel() void FairMQChannel::ResetChannel()
{ {
unique_lock<mutex> lock(fChannelMutex); unique_lock<mutex> lock(fChannelMutex);
@ -698,56 +669,24 @@ int FairMQChannel::Receive(unique_ptr<FairMQMessage>& msg) const
int FairMQChannel::Send(unique_ptr<FairMQMessage>& msg, int sndTimeoutInMs) const int FairMQChannel::Send(unique_ptr<FairMQMessage>& msg, int sndTimeoutInMs) const
{ {
fPoller->Poll(sndTimeoutInMs); return fSocket->Send(msg, sndTimeoutInMs);
if (fPoller->CheckInput(0))
{
HandleUnblock();
if (fInterrupted)
{
return -2;
}
}
if (fPoller->CheckOutput(1))
{
return Send(msg);
}
return -2;
} }
int FairMQChannel::Receive(unique_ptr<FairMQMessage>& msg, int rcvTimeoutInMs) const int FairMQChannel::Receive(unique_ptr<FairMQMessage>& msg, int rcvTimeoutInMs) const
{ {
fPoller->Poll(rcvTimeoutInMs); return fSocket->Receive(msg, rcvTimeoutInMs);
if (fPoller->CheckInput(0))
{
HandleUnblock();
if (fInterrupted)
{
return -2;
}
}
if (fPoller->CheckInput(1))
{
return Receive(msg);
}
return -2;
} }
int FairMQChannel::SendAsync(unique_ptr<FairMQMessage>& msg) const int FairMQChannel::SendAsync(unique_ptr<FairMQMessage>& msg) const
{ {
CheckCompatibility(msg); CheckCompatibility(msg);
return fSocket->SendAsync(msg); return fSocket->TrySend(msg);
} }
int FairMQChannel::ReceiveAsync(unique_ptr<FairMQMessage>& msg) const int FairMQChannel::ReceiveAsync(unique_ptr<FairMQMessage>& msg) const
{ {
CheckCompatibility(msg); CheckCompatibility(msg);
return fSocket->ReceiveAsync(msg); return fSocket->TryReceive(msg);
} }
int64_t FairMQChannel::Send(vector<unique_ptr<FairMQMessage>>& msgVec) const int64_t FairMQChannel::Send(vector<unique_ptr<FairMQMessage>>& msgVec) const
@ -764,50 +703,18 @@ int64_t FairMQChannel::Receive(vector<unique_ptr<FairMQMessage>>& msgVec) const
int64_t FairMQChannel::Send(vector<unique_ptr<FairMQMessage>>& msgVec, int sndTimeoutInMs) const int64_t FairMQChannel::Send(vector<unique_ptr<FairMQMessage>>& msgVec, int sndTimeoutInMs) const
{ {
fPoller->Poll(sndTimeoutInMs); return fSocket->Send(msgVec, sndTimeoutInMs);
if (fPoller->CheckInput(0))
{
HandleUnblock();
if (fInterrupted)
{
return -2;
}
}
if (fPoller->CheckOutput(1))
{
return Send(msgVec);
}
return -2;
} }
int64_t FairMQChannel::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, int rcvTimeoutInMs) const int64_t FairMQChannel::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, int rcvTimeoutInMs) const
{ {
fPoller->Poll(rcvTimeoutInMs); return fSocket->Receive(msgVec, rcvTimeoutInMs);
if (fPoller->CheckInput(0))
{
HandleUnblock();
if (fInterrupted)
{
return -2;
}
}
if (fPoller->CheckInput(1))
{
return Receive(msgVec);
}
return -2;
} }
int64_t FairMQChannel::SendAsync(vector<unique_ptr<FairMQMessage>>& msgVec) const int64_t FairMQChannel::SendAsync(vector<unique_ptr<FairMQMessage>>& msgVec) const
{ {
CheckCompatibility(msgVec); CheckCompatibility(msgVec);
return fSocket->SendAsync(msgVec); return fSocket->TrySend(msgVec);
} }
/// Receives a vector of messages in non-blocking mode. /// Receives a vector of messages in non-blocking mode.
@ -818,17 +725,7 @@ int64_t FairMQChannel::SendAsync(vector<unique_ptr<FairMQMessage>>& msgVec) cons
int64_t FairMQChannel::ReceiveAsync(vector<unique_ptr<FairMQMessage>>& msgVec) const int64_t FairMQChannel::ReceiveAsync(vector<unique_ptr<FairMQMessage>>& msgVec) const
{ {
CheckCompatibility(msgVec); CheckCompatibility(msgVec);
return fSocket->ReceiveAsync(msgVec); return fSocket->TryReceive(msgVec);
}
inline bool FairMQChannel::HandleUnblock() const
{
FairMQMessagePtr cmd(fTransportFactory->CreateMessage());
if (fChannelCmdSocket->Receive(cmd) >= 0)
{
// LOG(debug) << "unblocked";
}
return true;
} }
FairMQChannel::~FairMQChannel() FairMQChannel::~FairMQChannel()

8
fairmq/FairMQChannel.h
View File

@ -17,7 +17,6 @@
#include <FairMQTransportFactory.h> #include <FairMQTransportFactory.h>
#include <FairMQSocket.h> #include <FairMQSocket.h>
#include <FairMQPoller.h>
#include <fairmq/Transports.h> #include <fairmq/Transports.h>
#include <FairMQLogger.h> #include <FairMQLogger.h>
#include <FairMQParts.h> #include <FairMQParts.h>
@ -312,9 +311,6 @@ class FairMQChannel
std::string fName; std::string fName;
std::atomic<bool> fIsValid; std::atomic<bool> fIsValid;
FairMQPollerPtr fPoller;
FairMQSocketPtr fChannelCmdSocket;
FairMQ::Transport fTransportType; FairMQ::Transport fTransportType;
std::shared_ptr<FairMQTransportFactory> fTransportFactory; std::shared_ptr<FairMQTransportFactory> fTransportFactory;
@ -322,9 +318,6 @@ class FairMQChannel
bool CheckCompatibility(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) const; bool CheckCompatibility(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) const;
void InitTransport(std::shared_ptr<FairMQTransportFactory> factory); void InitTransport(std::shared_ptr<FairMQTransportFactory> factory);
bool InitCommandInterface(FairMQSocketPtr channelCmdSocket);
bool HandleUnblock() const;
// use static mutex to make the class easily copyable // use static mutex to make the class easily copyable
// implication: same mutex is used for all instances of the class // implication: same mutex is used for all instances of the class
@ -332,7 +325,6 @@ class FairMQChannel
// possible TODO: improve this // possible TODO: improve this
static std::mutex fChannelMutex; static std::mutex fChannelMutex;
static std::atomic<bool> fInterrupted;
bool fMultipart; bool fMultipart;
bool fModified; bool fModified;
auto SetModified(const bool modified) -> void; auto SetModified(const bool modified) -> void;

29
fairmq/FairMQDevice.cxx
View File

@ -48,7 +48,6 @@ FairMQDevice::FairMQDevice()
, fDefaultTransport() , fDefaultTransport()
, fInitializationTimeoutInS(120) , fInitializationTimeoutInS(120)
, fDataCallbacks(false) , fDataCallbacks(false)
, fDeviceCmdSocket(nullptr)
, fMsgInputs() , fMsgInputs()
, fMultipartInputs() , fMultipartInputs()
, fMultitransportInputs() , fMultitransportInputs()
@ -79,7 +78,6 @@ FairMQDevice::FairMQDevice(const fair::mq::tools::Version version)
, fDefaultTransport() , fDefaultTransport()
, fInitializationTimeoutInS(120) , fInitializationTimeoutInS(120)
, fDataCallbacks(false) , fDataCallbacks(false)
, fDeviceCmdSocket(nullptr)
, fMsgInputs() , fMsgInputs()
, fMultipartInputs() , fMultipartInputs()
, fMultitransportInputs() , fMultitransportInputs()
@ -116,8 +114,6 @@ void FairMQDevice::InitWrapper()
// if (vi->fReset) // if (vi->fReset)
// { // {
// vi->fSocket.reset(); // vi->fSocket.reset();
// vi->fPoller.reset();
// vi->fChannelCmdSocket.reset();
// } // }
// set channel name: name + vector index // set channel name: name + vector index
vi->fName = fair::mq::tools::ToString(mi.first, "[", vi - (mi.second).begin(), "]"); vi->fName = fair::mq::tools::ToString(mi.first, "[", vi - (mi.second).begin(), "]");
@ -233,7 +229,6 @@ void FairMQDevice::AttachChannels(vector<FairMQChannel*>& chans)
{ {
if (AttachChannel(**itr)) if (AttachChannel(**itr))
{ {
(*itr)->InitCommandInterface(Transport()->CreateSocket("sub", "device-commands"));
(*itr)->SetModified(false); (*itr)->SetModified(false);
itr = chans.erase(itr); itr = chans.erase(itr);
} }
@ -459,9 +454,11 @@ void FairMQDevice::RunWrapper()
// start the rate logger thread // start the rate logger thread
thread rateLogger(&FairMQDevice::LogSocketRates, this); thread rateLogger(&FairMQDevice::LogSocketRates, this);
// notify channels to resume transfers // notify transports to resume transfers
FairMQChannel::fInterrupted = false; for (auto& t : fTransports)
fDeviceCmdSocket->Resume(); {
t.second->Resume();
}
try try
{ {
@ -762,12 +759,6 @@ shared_ptr<FairMQTransportFactory> FairMQDevice::AddTransport(const string& tran
pair<FairMQ::Transport, shared_ptr<FairMQTransportFactory>> trPair(FairMQ::TransportTypes.at(transport), tr); pair<FairMQ::Transport, shared_ptr<FairMQTransportFactory>> trPair(FairMQ::TransportTypes.at(transport), tr);
fTransports.insert(trPair); fTransports.insert(trPair);
if (!fDeviceCmdSocket) {
fDeviceCmdSocket = Transport()->CreateSocket("pub", "device-commands");
if(!fDeviceCmdSocket->Bind("inproc://commands")) {
exit(EXIT_FAILURE);
}
}
return tr; return tr;
} }
else else
@ -949,10 +940,10 @@ void FairMQDevice::LogSocketRates()
void FairMQDevice::Unblock() void FairMQDevice::Unblock()
{ {
FairMQChannel::fInterrupted = true; for (auto& t : fTransports)
fDeviceCmdSocket->Interrupt(); {
FairMQMessagePtr cmd(Transport()->CreateMessage()); t.second->Interrupt();
fDeviceCmdSocket->Send(cmd); }
} }
void FairMQDevice::ResetTaskWrapper() void FairMQDevice::ResetTaskWrapper()
@ -987,8 +978,6 @@ void FairMQDevice::Reset()
{ {
// vi.fReset = true; // vi.fReset = true;
vi.fSocket.reset(); vi.fSocket.reset();
vi.fPoller.reset();
vi.fChannelCmdSocket.reset();
} }
} }
} }

1
fairmq/FairMQDevice.h
View File

@ -517,7 +517,6 @@ class FairMQDevice : public FairMQStateMachine
void CreateOwnConfig(); void CreateOwnConfig();
bool fDataCallbacks; bool fDataCallbacks;
FairMQSocketPtr fDeviceCmdSocket; ///< Socket used for the internal unblocking mechanism
std::unordered_map<std::string, InputMsgCallback> fMsgInputs; std::unordered_map<std::string, InputMsgCallback> fMsgInputs;
std::unordered_map<std::string, InputMultipartCallback> fMultipartInputs; std::unordered_map<std::string, InputMultipartCallback> fMultipartInputs;
std::unordered_map<FairMQ::Transport, std::vector<std::string>> fMultitransportInputs; std::unordered_map<FairMQ::Transport, std::vector<std::string>> fMultitransportInputs;

19
fairmq/FairMQSocket.h
View File

@ -25,24 +25,21 @@ class FairMQSocket
virtual bool Bind(const std::string& address) = 0; virtual bool Bind(const std::string& address) = 0;
virtual void Connect(const std::string& address) = 0; virtual void Connect(const std::string& address) = 0;
virtual int Send(FairMQMessagePtr& msg) = 0; virtual int Send(FairMQMessagePtr& msg, int timeout = 0) = 0;
virtual int SendAsync(FairMQMessagePtr& msg) = 0; virtual int Receive(FairMQMessagePtr& msg, int timeout = 0) = 0;
virtual int Receive(FairMQMessagePtr& msg) = 0; virtual int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = 0) = 0;
virtual int ReceiveAsync(FairMQMessagePtr& msg) = 0; virtual int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = 0) = 0;
virtual int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0; virtual int TrySend(FairMQMessagePtr& msg) = 0;
virtual int64_t SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0; virtual int TryReceive(FairMQMessagePtr& msg) = 0;
virtual int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0; virtual int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0;
virtual int64_t ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0; virtual int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0;
virtual void* GetSocket() const = 0; virtual void* GetSocket() const = 0;
virtual int GetSocket(int nothing) const = 0; virtual int GetSocket(int nothing) const = 0;
virtual void Close() = 0; virtual void Close() = 0;
virtual void Interrupt() = 0;
virtual void Resume() = 0;
virtual void SetOption(const std::string& option, const void* value, size_t valueSize) = 0; virtual void SetOption(const std::string& option, const void* value, size_t valueSize) = 0;
virtual void GetOption(const std::string& option, void* value, size_t* valueSize) = 0; virtual void GetOption(const std::string& option, void* value, size_t* valueSize) = 0;

3
fairmq/FairMQTransportFactory.h
View File

@ -71,6 +71,9 @@ class FairMQTransportFactory
/// Get transport type /// Get transport type
virtual FairMQ::Transport GetType() const = 0; virtual FairMQ::Transport GetType() const = 0;
virtual void Interrupt() = 0;
virtual void Resume() = 0;
virtual ~FairMQTransportFactory() noexcept(false) {}; virtual ~FairMQTransportFactory() noexcept(false) {};
static auto CreateTransportFactory(const std::string& type, const std::string& id = "", const FairMQProgOptions* config = nullptr) -> std::shared_ptr<FairMQTransportFactory>; static auto CreateTransportFactory(const std::string& type, const std::string& id = "", const FairMQProgOptions* config = nullptr) -> std::shared_ptr<FairMQTransportFactory>;

97
fairmq/nanomsg/FairMQSocketNN.cxx
View File

@ -39,6 +39,8 @@ FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const str
, fBytesRx(0) , fBytesRx(0)
, fMessagesTx(0) , fMessagesTx(0)
, fMessagesRx(0) , fMessagesRx(0)
, fSndTimeout(100)
, fRcvTimeout(100)
{ {
if (type == "router" || type == "dealer") if (type == "router" || type == "dealer")
{ {
@ -66,14 +68,12 @@ FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const str
} }
} }
int sndTimeout = 700; if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &sndTimeout, sizeof(sndTimeout)) != 0)
{ {
LOG(error) << "Failed setting NN_SNDTIMEO socket option, reason: " << nn_strerror(errno); LOG(error) << "Failed setting NN_SNDTIMEO socket option, reason: " << nn_strerror(errno);
} }
int rcvTimeout = 700; if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &rcvTimeout, sizeof(rcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting NN_RCVTIMEO socket option, reason: " << nn_strerror(errno); LOG(error) << "Failed setting NN_RCVTIMEO socket option, reason: " << nn_strerror(errno);
} }
@ -118,19 +118,20 @@ void FairMQSocketNN::Connect(const string& address)
} }
} }
int FairMQSocketNN::Send(FairMQMessagePtr& msg) { return Send(msg, 0); } int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int timeout) { return SendImpl(msg, 0, timeout); }
int FairMQSocketNN::SendAsync(FairMQMessagePtr& msg) { return Send(msg, NN_DONTWAIT); } int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int timeout) { return ReceiveImpl(msg, 0, timeout); }
int FairMQSocketNN::Receive(FairMQMessagePtr& msg) { return Receive(msg, 0); } int64_t FairMQSocketNN::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return SendImpl(msgVec, 0, timeout); }
int FairMQSocketNN::ReceiveAsync(FairMQMessagePtr& msg) { return Receive(msg, NN_DONTWAIT); } int64_t FairMQSocketNN::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return ReceiveImpl(msgVec, 0, timeout); }
int64_t FairMQSocketNN::Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Send(msgVec, 0); } int FairMQSocketNN::TrySend(FairMQMessagePtr& msg) { return SendImpl(msg, NN_DONTWAIT, 0); }
int64_t FairMQSocketNN::SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Send(msgVec, NN_DONTWAIT); } int FairMQSocketNN::TryReceive(FairMQMessagePtr& msg) { return ReceiveImpl(msg, NN_DONTWAIT, 0); }
int64_t FairMQSocketNN::Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Receive(msgVec, 0); } int64_t FairMQSocketNN::TrySend(vector<unique_ptr<FairMQMessage>>& msgVec) { return SendImpl(msgVec, NN_DONTWAIT, 0); }
int64_t FairMQSocketNN::ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Receive(msgVec, NN_DONTWAIT); } int64_t FairMQSocketNN::TryReceive(vector<unique_ptr<FairMQMessage>>& msgVec) { return ReceiveImpl(msgVec, NN_DONTWAIT, 0); }
int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int flags) int FairMQSocketNN::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
{ {
int nbytes = -1; int nbytes = -1;
int elapsed = 0;
FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get()); FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get());
void* bufPtr = msgPtr->GetMessage(); void* bufPtr = msgPtr->GetMessage();
@ -164,6 +165,14 @@ int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int flags)
{ {
if (!fInterrupted && ((flags & NN_DONTWAIT) == 0)) if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fSndTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -188,9 +197,10 @@ int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int flags)
} }
} }
int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int flags) int FairMQSocketNN::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
{ {
int nbytes = -1; int nbytes = -1;
int elapsed = 0;
FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get()); FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get());
@ -214,6 +224,14 @@ int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int flags)
{ {
if (!fInterrupted && ((flags & NN_DONTWAIT) == 0)) if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fRcvTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -238,10 +256,11 @@ int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int flags)
} }
} }
int64_t FairMQSocketNN::Send(vector<FairMQMessagePtr>& msgVec, const int flags) int64_t FairMQSocketNN::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
{ {
const unsigned int vecSize = msgVec.size(); const unsigned int vecSize = msgVec.size();
#ifdef MSGPACK_FOUND #ifdef MSGPACK_FOUND
int elapsed = 0;
// create msgpack simple buffer // create msgpack simple buffer
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
@ -282,6 +301,14 @@ int64_t FairMQSocketNN::Send(vector<FairMQMessagePtr>& msgVec, const int flags)
{ {
if (!fInterrupted && ((flags & NN_DONTWAIT) == 0)) if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fSndTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -310,7 +337,7 @@ int64_t FairMQSocketNN::Send(vector<FairMQMessagePtr>& msgVec, const int flags)
#endif /*MSGPACK_FOUND*/ #endif /*MSGPACK_FOUND*/
} }
int64_t FairMQSocketNN::Receive(vector<FairMQMessagePtr>& msgVec, const int flags) int64_t FairMQSocketNN::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
{ {
#ifdef MSGPACK_FOUND #ifdef MSGPACK_FOUND
// Warn if the vector is filled before Receive() and empty it. // Warn if the vector is filled before Receive() and empty it.
@ -320,6 +347,8 @@ int64_t FairMQSocketNN::Receive(vector<FairMQMessagePtr>& msgVec, const int flag
// msgVec.clear(); // msgVec.clear();
// } // }
int elapsed = 0;
while (true) while (true)
{ {
// pointer to point to received message buffer // pointer to point to received message buffer
@ -338,7 +367,7 @@ int64_t FairMQSocketNN::Receive(vector<FairMQMessagePtr>& msgVec, const int flag
while (offset != static_cast<size_t>(nbytes)) // continue until all parts have been read while (offset != static_cast<size_t>(nbytes)) // continue until all parts have been read
{ {
// vector of chars to hold blob (unlike char*/void* this type can be converted to by msgpack) // vector of chars to hold blob (unlike char*/void* this type can be converted to by msgpack)
std::vector<char> buf; vector<char> buf;
// unpack and convert chunk // unpack and convert chunk
msgpack::unpacked result; msgpack::unpacked result;
@ -364,6 +393,14 @@ int64_t FairMQSocketNN::Receive(vector<FairMQMessagePtr>& msgVec, const int flag
{ {
if (!fInterrupted && ((flags & NN_DONTWAIT) == 0)) if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fRcvTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -472,7 +509,8 @@ unsigned long FairMQSocketNN::GetMessagesRx() const
bool FairMQSocketNN::SetSendTimeout(const int timeout, const string& /*address*/, const string& /*method*/) bool FairMQSocketNN::SetSendTimeout(const int timeout, const string& /*address*/, const string& /*method*/)
{ {
if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &timeout, sizeof(int)) != 0) fSndTimeout = timeout;
if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
{ {
LOG(error) << "Failed setting option 'send timeout' on socket " << fId << ", reason: " << nn_strerror(errno); LOG(error) << "Failed setting option 'send timeout' on socket " << fId << ", reason: " << nn_strerror(errno);
return false; return false;
@ -483,20 +521,13 @@ bool FairMQSocketNN::SetSendTimeout(const int timeout, const string& /*address*/
int FairMQSocketNN::GetSendTimeout() const int FairMQSocketNN::GetSendTimeout() const
{ {
int timeout = -1; return fSndTimeout;
size_t size = sizeof(timeout);
if (nn_getsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &timeout, &size) != 0)
{
LOG(error) << "Failed getting option 'send timeout' on socket " << fId << ", reason: " << nn_strerror(errno);
}
return timeout;
} }
bool FairMQSocketNN::SetReceiveTimeout(const int timeout, const string& /*address*/, const string& /*method*/) bool FairMQSocketNN::SetReceiveTimeout(const int timeout, const string& /*address*/, const string& /*method*/)
{ {
if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &timeout, sizeof(int)) != 0) fRcvTimeout = timeout;
if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting option 'receive timeout' on socket " << fId << ", reason: " << nn_strerror(errno); LOG(error) << "Failed setting option 'receive timeout' on socket " << fId << ", reason: " << nn_strerror(errno);
return false; return false;
@ -507,15 +538,7 @@ bool FairMQSocketNN::SetReceiveTimeout(const int timeout, const string& /*addres
int FairMQSocketNN::GetReceiveTimeout() const int FairMQSocketNN::GetReceiveTimeout() const
{ {
int timeout = -1; return fRcvTimeout;
size_t size = sizeof(timeout);
if (nn_getsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &timeout, &size) != 0)
{
LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << nn_strerror(errno);
}
return timeout;
} }
int FairMQSocketNN::GetConstant(const string& constant) int FairMQSocketNN::GetConstant(const string& constant)

67
fairmq/nanomsg/FairMQSocketNN.h
View File

@ -22,44 +22,45 @@ class FairMQSocketNN : public FairMQSocket
FairMQSocketNN(const FairMQSocketNN&) = delete; FairMQSocketNN(const FairMQSocketNN&) = delete;
FairMQSocketNN operator=(const FairMQSocketNN&) = delete; FairMQSocketNN operator=(const FairMQSocketNN&) = delete;
virtual std::string GetId(); std::string GetId() override;
virtual bool Bind(const std::string& address); bool Bind(const std::string& address) override;
virtual void Connect(const std::string& address); void Connect(const std::string& address) override;
virtual int Send(FairMQMessagePtr& msg); int Send(FairMQMessagePtr& msg, const int timeout = 0) override;
virtual int SendAsync(FairMQMessagePtr& msg); int Receive(FairMQMessagePtr& msg, const int timeout = 0) override;
virtual int Receive(FairMQMessagePtr& msg); int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
virtual int ReceiveAsync(FairMQMessagePtr& msg); int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
virtual int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec); int TrySend(FairMQMessagePtr& msg) override;
virtual int64_t SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec); int TryReceive(FairMQMessagePtr& msg) override;
virtual int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec); int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
virtual int64_t ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec); int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
virtual void* GetSocket() const; void* GetSocket() const override;
virtual int GetSocket(int nothing) const; int GetSocket(int nothing) const override;
virtual void Close();
virtual void Interrupt(); void Close() override;
virtual void Resume();
virtual void SetOption(const std::string& option, const void* value, size_t valueSize); static void Interrupt();
virtual void GetOption(const std::string& option, void* value, size_t* valueSize); static void Resume();
unsigned long GetBytesTx() const; void SetOption(const std::string& option, const void* value, size_t valueSize) override;
unsigned long GetBytesRx() const; void GetOption(const std::string& option, void* value, size_t* valueSize) override;
unsigned long GetMessagesTx() const;
unsigned long GetMessagesRx() const;
virtual bool SetSendTimeout(const int timeout, const std::string& address, const std::string& method); unsigned long GetBytesTx() const override;
virtual int GetSendTimeout() const; unsigned long GetBytesRx() const override;
virtual bool SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method); unsigned long GetMessagesTx() const override;
virtual int GetReceiveTimeout() const; unsigned long GetMessagesRx() const override;
bool SetSendTimeout(const int timeout, const std::string& address, const std::string& method) override;
int GetSendTimeout() const override;
bool SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method) override;
int GetReceiveTimeout() const override;
static int GetConstant(const std::string& constant); static int GetConstant(const std::string& constant);
virtual ~FairMQSocketNN(); ~FairMQSocketNN() override;
private: private:
int fSocket; int fSocket;
@ -68,12 +69,16 @@ class FairMQSocketNN : public FairMQSocket
std::atomic<unsigned long> fBytesRx; std::atomic<unsigned long> fBytesRx;
std::atomic<unsigned long> fMessagesTx; std::atomic<unsigned long> fMessagesTx;
std::atomic<unsigned long> fMessagesRx; std::atomic<unsigned long> fMessagesRx;
static std::atomic<bool> fInterrupted; static std::atomic<bool> fInterrupted;
int Send(FairMQMessagePtr& msg, const int flags = 0); int fSndTimeout;
int Receive(FairMQMessagePtr& msg, const int flags = 0); int fRcvTimeout;
int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags = 0);
int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags = 0); int SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
int ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
int64_t SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
int64_t ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
}; };
#endif /* FAIRMQSOCKETNN_H_ */ #endif /* FAIRMQSOCKETNN_H_ */

3
fairmq/nanomsg/FairMQTransportFactoryNN.h
View File

@ -41,6 +41,9 @@ class FairMQTransportFactoryNN : public FairMQTransportFactory
FairMQ::Transport GetType() const override; FairMQ::Transport GetType() const override;
void Interrupt() override { FairMQSocketNN::Interrupt(); }
void Resume() override { FairMQSocketNN::Resume(); }
private: private:
static FairMQ::Transport fTransportType; static FairMQ::Transport fTransportType;
}; };

110
fairmq/ofi/Socket.cxx
View File

@ -27,6 +27,8 @@ Socket::Socket(const string& type, const string& name, const string& id /*= ""*/
, fBytesRx{0} , fBytesRx{0}
, fMessagesTx{0} , fMessagesTx{0}
, fMessagesRx{0} , fMessagesRx{0}
, fSndTimeout{100}
, fRcvTimeout{100}
{ {
assert(zmqContext); assert(zmqContext);
@ -51,13 +53,11 @@ Socket::Socket(const string& type, const string& name, const string& id /*= ""*/
throw SocketError{tools::ToString("Failed setting ZMQ_LINGER socket option, reason: ", zmq_strerror(errno))}; throw SocketError{tools::ToString("Failed setting ZMQ_LINGER socket option, reason: ", zmq_strerror(errno))};
} }
int sndTimeout = 700; if (zmq_setsockopt(fMetaSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0) {
if (zmq_setsockopt(fMetaSocket, ZMQ_SNDTIMEO, &sndTimeout, sizeof(sndTimeout)) != 0) {
throw SocketError{tools::ToString("Failed setting ZMQ_SNDTIMEO socket option, reason: ", zmq_strerror(errno))}; throw SocketError{tools::ToString("Failed setting ZMQ_SNDTIMEO socket option, reason: ", zmq_strerror(errno))};
} }
int rcvTimeout = 700; if (zmq_setsockopt(fMetaSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0) {
if (zmq_setsockopt(fMetaSocket, ZMQ_RCVTIMEO, &rcvTimeout, sizeof(rcvTimeout)) != 0) {
throw SocketError{tools::ToString("Failed setting ZMQ_RCVTIMEO socket option, reason: ", zmq_strerror(errno))}; throw SocketError{tools::ToString("Failed setting ZMQ_RCVTIMEO socket option, reason: ", zmq_strerror(errno))};
} }
} }
@ -83,20 +83,22 @@ auto Socket::Connect(const string& address) -> void
} }
} }
auto Socket::Send(FairMQMessagePtr& msg) -> int { return Send(msg, 0); } auto Socket::Send(FairMQMessagePtr& msg, const int timeout) -> int { return SendImpl(msg, 0, timeout); }
auto Socket::SendAsync(FairMQMessagePtr& msg) -> int { return Send(msg, ZMQ_DONTWAIT); } auto Socket::Receive(FairMQMessagePtr& msg, const int timeout) -> int { return ReceiveImpl(msg, 0, timeout); }
auto Socket::Receive(FairMQMessagePtr& msg) -> int { return Receive(msg, 0); } auto Socket::Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout) -> int64_t { return SendImpl(msgVec, 0, timeout); }
auto Socket::ReceiveAsync(FairMQMessagePtr& msg) -> int { return Receive(msg, ZMQ_DONTWAIT); } auto Socket::Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout) -> int64_t { return ReceiveImpl(msgVec, 0, timeout); }
auto Socket::Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t { return Send(msgVec, 0); } auto Socket::TrySend(FairMQMessagePtr& msg) -> int { return SendImpl(msg, ZMQ_DONTWAIT, 0); }
auto Socket::SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t { return Send(msgVec, ZMQ_DONTWAIT); } auto Socket::TryReceive(FairMQMessagePtr& msg) -> int { return ReceiveImpl(msg, ZMQ_DONTWAIT, 0); }
auto Socket::Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t { return Receive(msgVec, 0); } auto Socket::TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t { return SendImpl(msgVec, ZMQ_DONTWAIT, 0); }
auto Socket::ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t { return Receive(msgVec, ZMQ_DONTWAIT); } auto Socket::TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t { return ReceiveImpl(msgVec, ZMQ_DONTWAIT, 0); }
auto Socket::Send(FairMQMessagePtr& msg, const int flags) -> int auto Socket::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout) -> int
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// int nbytes = -1; // int nbytes = -1;
// int elapsed = 0;
//
// while (true && !fInterrupted) // while (true && !fInterrupted)
// { // {
// nbytes = zmq_msg_send(static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(), fSocket, flags); // nbytes = zmq_msg_send(static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(), fSocket, flags);
@ -118,6 +120,14 @@ auto Socket::Send(FairMQMessagePtr& msg, const int flags) -> int
// { // {
// if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) // if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
// { // {
// if (timeout)
// {
// elapsed += fSndTimeout;
// if (elapsed >= timeout)
// {
// return -2;
// }
// }
// continue; // continue;
// } // }
// else // else
@ -140,10 +150,12 @@ auto Socket::Send(FairMQMessagePtr& msg, const int flags) -> int
// return -1; // return -1;
} }
auto Socket::Receive(FairMQMessagePtr& msg, const int flags) -> int auto Socket::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout) -> int
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// int nbytes = -1; // int nbytes = -1;
// int elapsed = 0;
//
// zmq_msg_t* msgPtr = static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(); // zmq_msg_t* msgPtr = static_cast<FairMQMessageSHM*>(msg.get())->GetMessage();
// while (true) // while (true)
// { // {
@ -173,6 +185,14 @@ auto Socket::Receive(FairMQMessagePtr& msg, const int flags) -> int
// { // {
// if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) // if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
// { // {
// if (timeout)
// {
// elapsed += fSndTimeout;
// if (elapsed >= timeout)
// {
// return -2;
// }
// }
// continue; // continue;
// } // }
// else // else
@ -193,10 +213,11 @@ auto Socket::Receive(FairMQMessagePtr& msg, const int flags) -> int
// } // }
} }
auto Socket::Send(vector<FairMQMessagePtr>& msgVec, const int flags) -> int64_t auto Socket::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout) -> int64_t
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// const unsigned int vecSize = msgVec.size(); // const unsigned int vecSize = msgVec.size();
// int elapsed = 0;
// //
// // Sending vector typicaly handles more then one part // // Sending vector typicaly handles more then one part
// if (vecSize > 1) // if (vecSize > 1)
@ -226,6 +247,14 @@ auto Socket::Send(vector<FairMQMessagePtr>& msgVec, const int flags) -> int64_t
// { // {
// if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) // if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
// { // {
// if (timeout)
// {
// elapsed += fSndTimeout;
// if (elapsed >= timeout)
// {
// return -2;
// }
// }
// repeat = true; // repeat = true;
// break; // break;
// } // }
@ -268,12 +297,13 @@ auto Socket::Send(vector<FairMQMessagePtr>& msgVec, const int flags) -> int64_t
// } // }
} }
auto Socket::Receive(vector<FairMQMessagePtr>& msgVec, const int flags) -> int64_t auto Socket::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout) -> int64_t
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// int64_t totalSize = 0; // int64_t totalSize = 0;
// int64_t more = 0; // int64_t more = 0;
// bool repeat = false; // bool repeat = false;
// int elapsed = 0;
// //
// while (true) // while (true)
// { // {
@ -316,6 +346,14 @@ auto Socket::Receive(vector<FairMQMessagePtr>& msgVec, const int flags) -> int64
// { // {
// if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) // if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
// { // {
// if (timeout)
// {
// elapsed += fSndTimeout;
// if (elapsed >= timeout)
// {
// return -2;
// }
// }
// repeat = true; // repeat = true;
// break; // break;
// } // }
@ -353,16 +391,6 @@ auto Socket::Close() -> void
} }
} }
auto Socket::Interrupt() -> void
{
throw SocketError{"Not yet implemented."};
}
auto Socket::Resume() -> void
{
throw SocketError{"Not yet implemented."};
}
auto Socket::SetOption(const string& option, const void* value, size_t valueSize) -> void auto Socket::SetOption(const string& option, const void* value, size_t valueSize) -> void
{ {
if (zmq_setsockopt(fMetaSocket, GetConstant(option), value, valueSize) < 0) { if (zmq_setsockopt(fMetaSocket, GetConstant(option), value, valueSize) < 0) {
@ -380,6 +408,7 @@ auto Socket::GetOption(const string& option, void* value, size_t* valueSize) ->
auto Socket::SetSendTimeout(const int timeout, const string& address, const string& method) -> bool auto Socket::SetSendTimeout(const int timeout, const string& address, const string& method) -> bool
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// fSndTimeout = timeout;
// if (method == "bind") // if (method == "bind")
// { // {
// if (zmq_unbind(fSocket, address.c_str()) != 0) // if (zmq_unbind(fSocket, address.c_str()) != 0)
@ -387,7 +416,7 @@ auto Socket::SetSendTimeout(const int timeout, const string& address, const stri
// LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
// } // }
// if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, sizeof(int)) != 0) // if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
// { // {
// LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
@ -405,7 +434,7 @@ auto Socket::SetSendTimeout(const int timeout, const string& address, const stri
// LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
// } // }
// if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, sizeof(int)) != 0) // if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
// { // {
// LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
@ -428,20 +457,13 @@ auto Socket::SetSendTimeout(const int timeout, const string& address, const stri
auto Socket::GetSendTimeout() const -> int auto Socket::GetSendTimeout() const -> int
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// int timeout = -1; // return fSndTimeout;
// size_t size = sizeof(timeout);
//
// if (zmq_getsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, &size) != 0)
// {
// LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << zmq_strerror(errno);
// }
//
// return timeout;
} }
auto Socket::SetReceiveTimeout(const int timeout, const string& address, const string& method) -> bool auto Socket::SetReceiveTimeout(const int timeout, const string& address, const string& method) -> bool
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// fRcvTimeout = timeout;
// if (method == "bind") // if (method == "bind")
// { // {
// if (zmq_unbind(fSocket, address.c_str()) != 0) // if (zmq_unbind(fSocket, address.c_str()) != 0)
@ -449,7 +471,7 @@ auto Socket::SetReceiveTimeout(const int timeout, const string& address, const s
// LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
// } // }
// if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, sizeof(int)) != 0) // if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
// { // {
// LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
@ -467,7 +489,7 @@ auto Socket::SetReceiveTimeout(const int timeout, const string& address, const s
// LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
// } // }
// if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, sizeof(int)) != 0) // if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
// { // {
// LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); // LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
// return false; // return false;
@ -490,15 +512,7 @@ auto Socket::SetReceiveTimeout(const int timeout, const string& address, const s
auto Socket::GetReceiveTimeout() const -> int auto Socket::GetReceiveTimeout() const -> int
{ {
throw SocketError{"Not yet implemented."}; throw SocketError{"Not yet implemented."};
// int timeout = -1; // return fRcvTimeout;
// size_t size = sizeof(timeout);
//
// if (zmq_getsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, &size) != 0)
// {
// LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << zmq_strerror(errno);
// }
//
// return timeout;
} }
auto Socket::GetConstant(const string& constant) -> int auto Socket::GetConstant(const string& constant) -> int

30
fairmq/ofi/Socket.h
View File

@ -39,24 +39,21 @@ class Socket : public FairMQSocket
auto Bind(const std::string& address) -> bool override; auto Bind(const std::string& address) -> bool override;
auto Connect(const std::string& address) -> void override; auto Connect(const std::string& address) -> void override;
auto Send(FairMQMessagePtr& msg) -> int override; auto Send(FairMQMessagePtr& msg, int timeout = 0) -> int override;
auto SendAsync(FairMQMessagePtr& msg) -> int override; auto Receive(FairMQMessagePtr& msg, int timeout = 0) -> int override;
auto Receive(FairMQMessagePtr& msg) -> int override; auto Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = 0) -> int64_t override;
auto ReceiveAsync(FairMQMessagePtr& msg) -> int override; auto Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = 0) -> int64_t override;
auto Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t override; auto TrySend(FairMQMessagePtr& msg) -> int override;
auto SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t override; auto TryReceive(FairMQMessagePtr& msg) -> int override;
auto Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t override; auto TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t override;
auto ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t override; auto TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) -> int64_t override;
auto GetSocket() const -> void* override { return fMetaSocket; } auto GetSocket() const -> void* override { return fMetaSocket; }
auto GetSocket(int nothing) const -> int override { return -1; } auto GetSocket(int nothing) const -> int override { return -1; }
auto Close() -> void override; auto Close() -> void override;
auto Interrupt() -> void override;
auto Resume() -> void override;
auto SetOption(const std::string& option, const void* value, size_t valueSize) -> void override; auto SetOption(const std::string& option, const void* value, size_t valueSize) -> void override;
auto GetOption(const std::string& option, void* value, size_t* valueSize) -> void override; auto GetOption(const std::string& option, void* value, size_t* valueSize) -> void override;
@ -82,10 +79,13 @@ class Socket : public FairMQSocket
std::atomic<unsigned long> fMessagesTx; std::atomic<unsigned long> fMessagesTx;
std::atomic<unsigned long> fMessagesRx; std::atomic<unsigned long> fMessagesRx;
auto Send(FairMQMessagePtr& msg, const int flags) -> int; int fSndTimeout;
auto Receive(FairMQMessagePtr& msg, const int flags) -> int; int fRcvTimeout;
auto Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags) -> int64_t;
auto Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags) -> int64_t; auto SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout) -> int;
auto ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout) -> int;
auto SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout) -> int64_t;
auto ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout) -> int64_t;
}; /* class Socket */ }; /* class Socket */
} /* namespace ofi */ } /* namespace ofi */

3
fairmq/ofi/TransportFactory.h
View File

@ -48,6 +48,9 @@ class TransportFactory : public FairMQTransportFactory
auto GetType() const -> Transport override; auto GetType() const -> Transport override;
void Interrupt() override {}
void Resume() override {}
~TransportFactory() noexcept(false) override; ~TransportFactory() noexcept(false) override;
private: private:

145
fairmq/shmem/FairMQSocketSHM.cxx
View File

@ -27,6 +27,8 @@ FairMQSocketSHM::FairMQSocketSHM(Manager& manager, const string& type, const str
, fBytesRx(0) , fBytesRx(0)
, fMessagesTx(0) , fMessagesTx(0)
, fMessagesRx(0) , fMessagesRx(0)
, fSndTimeout(100)
, fRcvTimeout(100)
{ {
assert(context); assert(context);
fSocket = zmq_socket(context, GetConstant(type)); fSocket = zmq_socket(context, GetConstant(type));
@ -50,14 +52,12 @@ FairMQSocketSHM::FairMQSocketSHM(Manager& manager, const string& type, const str
LOG(error) << "Failed setting ZMQ_LINGER socket option, reason: " << zmq_strerror(errno); LOG(error) << "Failed setting ZMQ_LINGER socket option, reason: " << zmq_strerror(errno);
} }
int sndTimeout = 700; if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &sndTimeout, sizeof(sndTimeout)) != 0)
{ {
LOG(error) << "Failed setting ZMQ_SNDTIMEO socket option, reason: " << zmq_strerror(errno); LOG(error) << "Failed setting ZMQ_SNDTIMEO socket option, reason: " << zmq_strerror(errno);
} }
int rcvTimeout = 700; if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &rcvTimeout, sizeof(rcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting ZMQ_RCVTIMEO socket option, reason: " << zmq_strerror(errno); LOG(error) << "Failed setting ZMQ_RCVTIMEO socket option, reason: " << zmq_strerror(errno);
} }
@ -101,19 +101,21 @@ void FairMQSocketSHM::Connect(const string& address)
} }
} }
int FairMQSocketSHM::Send(FairMQMessagePtr& msg) { return Send(msg, 0); } int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int timeout) { return SendImpl(msg, 0, timeout); }
int FairMQSocketSHM::SendAsync(FairMQMessagePtr& msg) { return Send(msg, ZMQ_DONTWAIT); } int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int timeout) { return ReceiveImpl(msg, 0, timeout); }
int FairMQSocketSHM::Receive(FairMQMessagePtr& msg) { return Receive(msg, 0); } int64_t FairMQSocketSHM::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return SendImpl(msgVec, 0, timeout); }
int FairMQSocketSHM::ReceiveAsync(FairMQMessagePtr& msg) { return Receive(msg, ZMQ_DONTWAIT); } int64_t FairMQSocketSHM::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return ReceiveImpl(msgVec, 0, timeout); }
int64_t FairMQSocketSHM::Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Send(msgVec, 0); } int FairMQSocketSHM::TrySend(FairMQMessagePtr& msg) { return SendImpl(msg, ZMQ_DONTWAIT, 0); }
int64_t FairMQSocketSHM::SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Send(msgVec, ZMQ_DONTWAIT); } int FairMQSocketSHM::TryReceive(FairMQMessagePtr& msg) { return ReceiveImpl(msg, ZMQ_DONTWAIT, 0); }
int64_t FairMQSocketSHM::Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Receive(msgVec, 0); } int64_t FairMQSocketSHM::TrySend(vector<unique_ptr<FairMQMessage>>& msgVec) { return SendImpl(msgVec, ZMQ_DONTWAIT, 0); }
int64_t FairMQSocketSHM::ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Receive(msgVec, ZMQ_DONTWAIT); } int64_t FairMQSocketSHM::TryReceive(vector<unique_ptr<FairMQMessage>>& msgVec) { return ReceiveImpl(msgVec, ZMQ_DONTWAIT, 0); }
int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int flags) int FairMQSocketSHM::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
{ {
int nbytes = -1; int nbytes = -1;
int elapsed = 0;
while (true && !fInterrupted) while (true && !fInterrupted)
{ {
nbytes = zmq_msg_send(static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(), fSocket, flags); nbytes = zmq_msg_send(static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(), fSocket, flags);
@ -135,6 +137,14 @@ int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int flags)
{ {
if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fSndTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -157,7 +167,7 @@ int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int flags)
return -1; return -1;
} }
int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int flags) int FairMQSocketSHM::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
{ {
int nbytes = -1; int nbytes = -1;
@ -199,6 +209,14 @@ int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int flags)
{ {
if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fRcvTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -219,7 +237,7 @@ int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int flags)
} }
} }
int64_t FairMQSocketSHM::Send(vector<FairMQMessagePtr>& msgVec, const int flags) int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
{ {
const unsigned int vecSize = msgVec.size(); const unsigned int vecSize = msgVec.size();
int64_t totalSize = 0; int64_t totalSize = 0;
@ -392,14 +410,14 @@ void FairMQSocketSHM::Close()
void FairMQSocketSHM::Interrupt() void FairMQSocketSHM::Interrupt()
{ {
fManager.Interrupt(); Manager::Interrupt();
FairMQMessageSHM::fInterrupted = true; FairMQMessageSHM::fInterrupted = true;
fInterrupted = true; fInterrupted = true;
} }
void FairMQSocketSHM::Resume() void FairMQSocketSHM::Resume()
{ {
fManager.Resume(); Manager::Resume();
FairMQMessageSHM::fInterrupted = false; FairMQMessageSHM::fInterrupted = false;
fInterrupted = false; fInterrupted = false;
} }
@ -453,6 +471,7 @@ unsigned long FairMQSocketSHM::GetMessagesRx() const
bool FairMQSocketSHM::SetSendTimeout(const int timeout, const string& address, const string& method) bool FairMQSocketSHM::SetSendTimeout(const int timeout, const string& address, const string& method)
{ {
fSndTimeout = timeout;
if (method == "bind") if (method == "bind")
{ {
if (zmq_unbind(fSocket, address.c_str()) != 0) if (zmq_unbind(fSocket, address.c_str()) != 0)
@ -460,7 +479,7 @@ bool FairMQSocketSHM::SetSendTimeout(const int timeout, const string& address, c
LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -478,7 +497,7 @@ bool FairMQSocketSHM::SetSendTimeout(const int timeout, const string& address, c
LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -500,19 +519,12 @@ bool FairMQSocketSHM::SetSendTimeout(const int timeout, const string& address, c
int FairMQSocketSHM::GetSendTimeout() const int FairMQSocketSHM::GetSendTimeout() const
{ {
int timeout = -1; return fSndTimeout;
size_t size = sizeof(timeout);
if (zmq_getsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, &size) != 0)
{
LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << zmq_strerror(errno);
}
return timeout;
} }
bool FairMQSocketSHM::SetReceiveTimeout(const int timeout, const string& address, const string& method) bool FairMQSocketSHM::SetReceiveTimeout(const int timeout, const string& address, const string& method)
{ {
fRcvTimeout = timeout;
if (method == "bind") if (method == "bind")
{ {
if (zmq_unbind(fSocket, address.c_str()) != 0) if (zmq_unbind(fSocket, address.c_str()) != 0)
@ -520,7 +532,7 @@ bool FairMQSocketSHM::SetReceiveTimeout(const int timeout, const string& address
LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -538,7 +550,7 @@ bool FairMQSocketSHM::SetReceiveTimeout(const int timeout, const string& address
LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -560,63 +572,34 @@ bool FairMQSocketSHM::SetReceiveTimeout(const int timeout, const string& address
int FairMQSocketSHM::GetReceiveTimeout() const int FairMQSocketSHM::GetReceiveTimeout() const
{ {
int timeout = -1; return fRcvTimeout;
size_t size = sizeof(timeout);
if (zmq_getsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, &size) != 0)
{
LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << zmq_strerror(errno);
}
return timeout;
} }
int FairMQSocketSHM::GetConstant(const string& constant) int FairMQSocketSHM::GetConstant(const string& constant)
{ {
if (constant == "") if (constant == "") return 0;
return 0; if (constant == "sub") return ZMQ_SUB;
if (constant == "sub") if (constant == "pub") return ZMQ_PUB;
return ZMQ_SUB; if (constant == "xsub") return ZMQ_XSUB;
if (constant == "pub") if (constant == "xpub") return ZMQ_XPUB;
return ZMQ_PUB; if (constant == "push") return ZMQ_PUSH;
if (constant == "xsub") if (constant == "pull") return ZMQ_PULL;
return ZMQ_XSUB; if (constant == "req") return ZMQ_REQ;
if (constant == "xpub") if (constant == "rep") return ZMQ_REP;
return ZMQ_XPUB; if (constant == "dealer") return ZMQ_DEALER;
if (constant == "push") if (constant == "router") return ZMQ_ROUTER;
return ZMQ_PUSH; if (constant == "pair") return ZMQ_PAIR;
if (constant == "pull")
return ZMQ_PULL;
if (constant == "req")
return ZMQ_REQ;
if (constant == "rep")
return ZMQ_REP;
if (constant == "dealer")
return ZMQ_DEALER;
if (constant == "router")
return ZMQ_ROUTER;
if (constant == "pair")
return ZMQ_PAIR;
if (constant == "snd-hwm") if (constant == "snd-hwm") return ZMQ_SNDHWM;
return ZMQ_SNDHWM; if (constant == "rcv-hwm") return ZMQ_RCVHWM;
if (constant == "rcv-hwm") if (constant == "snd-size") return ZMQ_SNDBUF;
return ZMQ_RCVHWM; if (constant == "rcv-size") return ZMQ_RCVBUF;
if (constant == "snd-size") if (constant == "snd-more") return ZMQ_SNDMORE;
return ZMQ_SNDBUF; if (constant == "rcv-more") return ZMQ_RCVMORE;
if (constant == "rcv-size")
return ZMQ_RCVBUF;
if (constant == "snd-more")
return ZMQ_SNDMORE;
if (constant == "rcv-more")
return ZMQ_RCVMORE;
if (constant == "linger") if (constant == "linger") return ZMQ_LINGER;
return ZMQ_LINGER; if (constant == "no-block") return ZMQ_DONTWAIT;
if (constant == "no-block") if (constant == "snd-more no-block") return ZMQ_DONTWAIT|ZMQ_SNDMORE;
return ZMQ_DONTWAIT;
if (constant == "snd-more no-block")
return ZMQ_DONTWAIT|ZMQ_SNDMORE;
return -1; return -1;
} }

33
fairmq/shmem/FairMQSocketSHM.h
View File

@ -28,22 +28,23 @@ class FairMQSocketSHM : public FairMQSocket
bool Bind(const std::string& address) override; bool Bind(const std::string& address) override;
void Connect(const std::string& address) override; void Connect(const std::string& address) override;
int Send(FairMQMessagePtr& msg) override; int Send(FairMQMessagePtr& msg, const int timeout = 0) override;
int SendAsync(FairMQMessagePtr& msg) override; int Receive(FairMQMessagePtr& msg, const int timeout = 0) override;
int Receive(FairMQMessagePtr& msg) override; int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
int ReceiveAsync(FairMQMessagePtr& msg) override; int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int TrySend(FairMQMessagePtr& msg) override;
int64_t SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int TryReceive(FairMQMessagePtr& msg) override;
int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
int64_t ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
void* GetSocket() const override; void* GetSocket() const override;
int GetSocket(int nothing) const override; int GetSocket(int nothing) const override;
void Close() override; void Close() override;
void Interrupt() override; static void Interrupt();
void Resume() override; static void Resume();
void SetOption(const std::string& option, const void* value, size_t valueSize) override; void SetOption(const std::string& option, const void* value, size_t valueSize) override;
void GetOption(const std::string& option, void* value, size_t* valueSize) override; void GetOption(const std::string& option, void* value, size_t* valueSize) override;
@ -73,10 +74,14 @@ class FairMQSocketSHM : public FairMQSocket
static std::atomic<bool> fInterrupted; static std::atomic<bool> fInterrupted;
int Send(FairMQMessagePtr& msg, const int flags); int fSndTimeout;
int Receive(FairMQMessagePtr& msg, const int flags); int fRcvTimeout;
int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags);
int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags); int SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
int ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
int64_t SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
int64_t ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
}; };
#endif /* FAIRMQSOCKETSHM_H_ */ #endif /* FAIRMQSOCKETSHM_H_ */

3
fairmq/shmem/FairMQTransportFactorySHM.h
View File

@ -49,6 +49,9 @@ class FairMQTransportFactorySHM : public FairMQTransportFactory
FairMQ::Transport GetType() const override; FairMQ::Transport GetType() const override;
void Interrupt() override { FairMQSocketSHM::Interrupt(); }
void Resume() override { FairMQSocketSHM::Resume(); }
~FairMQTransportFactorySHM() override; ~FairMQTransportFactorySHM() override;
private: private:

3
fairmq/shmem/Manager.cxx
View File

@ -19,13 +19,14 @@ namespace shmem
using namespace std; using namespace std;
namespace bipc = boost::interprocess; namespace bipc = boost::interprocess;
std::unordered_map<uint64_t, Region> Manager::fRegions;
Manager::Manager(const string& name, size_t size) Manager::Manager(const string& name, size_t size)
: fSessionName(name) : fSessionName(name)
, fSegmentName("fmq_shm_" + fSessionName + "_main") , fSegmentName("fmq_shm_" + fSessionName + "_main")
, fManagementSegmentName("fmq_shm_" + fSessionName + "_management") , fManagementSegmentName("fmq_shm_" + fSessionName + "_management")
, fSegment(bipc::open_or_create, fSegmentName.c_str(), size) , fSegment(bipc::open_or_create, fSegmentName.c_str(), size)
, fManagementSegment(bipc::open_or_create, fManagementSegmentName.c_str(), 65536) , fManagementSegment(bipc::open_or_create, fManagementSegmentName.c_str(), 65536)
, fRegions()
{} {}
bipc::managed_shared_memory& Manager::Segment() bipc::managed_shared_memory& Manager::Segment()

6
fairmq/shmem/Manager.h
View File

@ -49,8 +49,8 @@ class Manager
boost::interprocess::managed_shared_memory& Segment(); boost::interprocess::managed_shared_memory& Segment();
void Interrupt(); static void Interrupt();
void Resume(); static void Resume();
boost::interprocess::mapped_region* CreateRegion(const size_t size, const uint64_t id, FairMQRegionCallback callback); boost::interprocess::mapped_region* CreateRegion(const size_t size, const uint64_t id, FairMQRegionCallback callback);
Region* GetRemoteRegion(const uint64_t id); Region* GetRemoteRegion(const uint64_t id);
@ -66,7 +66,7 @@ class Manager
std::string fManagementSegmentName; std::string fManagementSegmentName;
boost::interprocess::managed_shared_memory fSegment; boost::interprocess::managed_shared_memory fSegment;
boost::interprocess::managed_shared_memory fManagementSegment; boost::interprocess::managed_shared_memory fManagementSegment;
std::unordered_map<uint64_t, Region> fRegions; static std::unordered_map<uint64_t, Region> fRegions;
}; };
} // namespace shmem } // namespace shmem

4
fairmq/test/protocols/_transfer_timeout.cxx
View File

@ -22,8 +22,8 @@ auto RunTransferTimeout(string transport) -> void
{ {
size_t session{fair::mq::tools::UuidHash()}; size_t session{fair::mq::tools::UuidHash()};
stringstream cmd; stringstream cmd;
cmd << runTestDevice << " --id transfer_timeout_" << transport << " --control static " cmd << runTestDevice << " --id transfer_timeout_" << transport << " --control static --transport " << transport
<< "--session " << session << " --color false --mq-config \"" << mqConfig << "\""; << " --session " << session << " --color false --mq-config \"" << mqConfig << "\"";
auto res = execute(cmd.str()); auto res = execute(cmd.str());
cerr << res.console_out; cerr << res.console_out;

155
fairmq/zeromq/FairMQSocketZMQ.cxx
View File

@ -23,6 +23,8 @@ FairMQSocketZMQ::FairMQSocketZMQ(const string& type, const string& name, const s
, fBytesRx(0) , fBytesRx(0)
, fMessagesTx(0) , fMessagesTx(0)
, fMessagesRx(0) , fMessagesRx(0)
, fSndTimeout(100)
, fRcvTimeout(100)
{ {
assert(context); assert(context);
fSocket = zmq_socket(context, GetConstant(type)); fSocket = zmq_socket(context, GetConstant(type));
@ -46,14 +48,12 @@ FairMQSocketZMQ::FairMQSocketZMQ(const string& type, const string& name, const s
LOG(error) << "Failed setting ZMQ_LINGER socket option, reason: " << zmq_strerror(errno); LOG(error) << "Failed setting ZMQ_LINGER socket option, reason: " << zmq_strerror(errno);
} }
int sndTimeout = 700; if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &sndTimeout, sizeof(sndTimeout)) != 0)
{ {
LOG(error) << "Failed setting ZMQ_SNDTIMEO socket option, reason: " << zmq_strerror(errno); LOG(error) << "Failed setting ZMQ_SNDTIMEO socket option, reason: " << zmq_strerror(errno);
} }
int rcvTimeout = 700; if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &rcvTimeout, sizeof(rcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting ZMQ_RCVTIMEO socket option, reason: " << zmq_strerror(errno); LOG(error) << "Failed setting ZMQ_RCVTIMEO socket option, reason: " << zmq_strerror(errno);
} }
@ -102,19 +102,20 @@ void FairMQSocketZMQ::Connect(const string& address)
} }
} }
int FairMQSocketZMQ::Send(FairMQMessagePtr& msg) { return Send(msg, 0); } int FairMQSocketZMQ::Send(FairMQMessagePtr& msg, const int timeout) { return SendImpl(msg, 0, timeout); }
int FairMQSocketZMQ::SendAsync(FairMQMessagePtr& msg) { return Send(msg, ZMQ_DONTWAIT); } int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg, const int timeout) { return ReceiveImpl(msg, 0, timeout); }
int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg) { return Receive(msg, 0); } int64_t FairMQSocketZMQ::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return SendImpl(msgVec, 0, timeout); }
int FairMQSocketZMQ::ReceiveAsync(FairMQMessagePtr& msg) { return Receive(msg, ZMQ_DONTWAIT); } int64_t FairMQSocketZMQ::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return ReceiveImpl(msgVec, 0, timeout); }
int64_t FairMQSocketZMQ::Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Send(msgVec, 0); } int FairMQSocketZMQ::TrySend(FairMQMessagePtr& msg) { return SendImpl(msg, ZMQ_DONTWAIT, 0); }
int64_t FairMQSocketZMQ::SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Send(msgVec, ZMQ_DONTWAIT); } int FairMQSocketZMQ::TryReceive(FairMQMessagePtr& msg) { return ReceiveImpl(msg, ZMQ_DONTWAIT, 0); }
int64_t FairMQSocketZMQ::Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Receive(msgVec, 0); } int64_t FairMQSocketZMQ::TrySend(vector<unique_ptr<FairMQMessage>>& msgVec) { return SendImpl(msgVec, ZMQ_DONTWAIT, 0); }
int64_t FairMQSocketZMQ::ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) { return Receive(msgVec, ZMQ_DONTWAIT); } int64_t FairMQSocketZMQ::TryReceive(vector<unique_ptr<FairMQMessage>>& msgVec) { return ReceiveImpl(msgVec, ZMQ_DONTWAIT, 0); }
int FairMQSocketZMQ::Send(FairMQMessagePtr& msg, const int flags) int FairMQSocketZMQ::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
{ {
int nbytes = -1; int nbytes = -1;
int elapsed = 0;
static_cast<FairMQMessageZMQ*>(msg.get())->ApplyUsedSize(); static_cast<FairMQMessageZMQ*>(msg.get())->ApplyUsedSize();
@ -132,6 +133,14 @@ int FairMQSocketZMQ::Send(FairMQMessagePtr& msg, const int flags)
{ {
if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fSndTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -152,9 +161,10 @@ int FairMQSocketZMQ::Send(FairMQMessagePtr& msg, const int flags)
} }
} }
int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg, const int flags) int FairMQSocketZMQ::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
{ {
int nbytes = -1; int nbytes = -1;
int elapsed = 0;
while (true) while (true)
{ {
@ -169,6 +179,14 @@ int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg, const int flags)
{ {
if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fRcvTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
continue; continue;
} }
else else
@ -189,9 +207,10 @@ int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg, const int flags)
} }
} }
int64_t FairMQSocketZMQ::Send(vector<FairMQMessagePtr>& msgVec, const int flags) int64_t FairMQSocketZMQ::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
{ {
const unsigned int vecSize = msgVec.size(); const unsigned int vecSize = msgVec.size();
int elapsed = 0;
// Sending vector typicaly handles more then one part // Sending vector typicaly handles more then one part
if (vecSize > 1) if (vecSize > 1)
@ -223,6 +242,14 @@ int64_t FairMQSocketZMQ::Send(vector<FairMQMessagePtr>& msgVec, const int flags)
{ {
if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fSndTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
repeat = true; repeat = true;
break; break;
} }
@ -263,11 +290,12 @@ int64_t FairMQSocketZMQ::Send(vector<FairMQMessagePtr>& msgVec, const int flags)
} }
} }
int64_t FairMQSocketZMQ::Receive(vector<FairMQMessagePtr>& msgVec, const int flags) int64_t FairMQSocketZMQ::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
{ {
int64_t totalSize = 0; int64_t totalSize = 0;
int64_t more = 0; int64_t more = 0;
bool repeat = false; bool repeat = false;
int elapsed = 0;
while (true) while (true)
{ {
@ -289,6 +317,14 @@ int64_t FairMQSocketZMQ::Receive(vector<FairMQMessagePtr>& msgVec, const int fla
{ {
if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0)) if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
{ {
if (timeout)
{
elapsed += fRcvTimeout;
if (elapsed >= timeout)
{
return -2;
}
}
repeat = true; repeat = true;
break; break;
} }
@ -395,6 +431,7 @@ unsigned long FairMQSocketZMQ::GetMessagesRx() const
bool FairMQSocketZMQ::SetSendTimeout(const int timeout, const string& address, const string& method) bool FairMQSocketZMQ::SetSendTimeout(const int timeout, const string& address, const string& method)
{ {
fSndTimeout = timeout;
if (method == "bind") if (method == "bind")
{ {
if (zmq_unbind(fSocket, address.c_str()) != 0) if (zmq_unbind(fSocket, address.c_str()) != 0)
@ -402,7 +439,7 @@ bool FairMQSocketZMQ::SetSendTimeout(const int timeout, const string& address, c
LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -420,7 +457,7 @@ bool FairMQSocketZMQ::SetSendTimeout(const int timeout, const string& address, c
LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -442,19 +479,12 @@ bool FairMQSocketZMQ::SetSendTimeout(const int timeout, const string& address, c
int FairMQSocketZMQ::GetSendTimeout() const int FairMQSocketZMQ::GetSendTimeout() const
{ {
int timeout = -1; return fSndTimeout;
size_t size = sizeof(timeout);
if (zmq_getsockopt(fSocket, ZMQ_SNDTIMEO, &timeout, &size) != 0)
{
LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << zmq_strerror(errno);
}
return timeout;
} }
bool FairMQSocketZMQ::SetReceiveTimeout(const int timeout, const string& address, const string& method) bool FairMQSocketZMQ::SetReceiveTimeout(const int timeout, const string& address, const string& method)
{ {
fRcvTimeout = timeout;
if (method == "bind") if (method == "bind")
{ {
if (zmq_unbind(fSocket, address.c_str()) != 0) if (zmq_unbind(fSocket, address.c_str()) != 0)
@ -462,7 +492,7 @@ bool FairMQSocketZMQ::SetReceiveTimeout(const int timeout, const string& address
LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -480,7 +510,7 @@ bool FairMQSocketZMQ::SetReceiveTimeout(const int timeout, const string& address
LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
} }
if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, sizeof(int)) != 0) if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
{ {
LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno); LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
return false; return false;
@ -502,59 +532,32 @@ bool FairMQSocketZMQ::SetReceiveTimeout(const int timeout, const string& address
int FairMQSocketZMQ::GetReceiveTimeout() const int FairMQSocketZMQ::GetReceiveTimeout() const
{ {
int timeout = -1; return fRcvTimeout;
size_t size = sizeof(timeout);
if (zmq_getsockopt(fSocket, ZMQ_RCVTIMEO, &timeout, &size) != 0)
{
LOG(error) << "Failed getting option 'receive timeout' on socket " << fId << ", reason: " << zmq_strerror(errno);
}
return timeout;
} }
int FairMQSocketZMQ::GetConstant(const string& constant) int FairMQSocketZMQ::GetConstant(const string& constant)
{ {
if (constant == "") if (constant == "") return 0;
return 0; if (constant == "sub") return ZMQ_SUB;
if (constant == "sub") if (constant == "pub") return ZMQ_PUB;
return ZMQ_SUB; if (constant == "xsub") return ZMQ_XSUB;
if (constant == "pub") if (constant == "xpub") return ZMQ_XPUB;
return ZMQ_PUB; if (constant == "push") return ZMQ_PUSH;
if (constant == "xsub") if (constant == "pull") return ZMQ_PULL;
return ZMQ_XSUB; if (constant == "req") return ZMQ_REQ;
if (constant == "xpub") if (constant == "rep") return ZMQ_REP;
return ZMQ_XPUB; if (constant == "dealer") return ZMQ_DEALER;
if (constant == "push") if (constant == "router") return ZMQ_ROUTER;
return ZMQ_PUSH; if (constant == "pair") return ZMQ_PAIR;
if (constant == "pull")
return ZMQ_PULL;
if (constant == "req")
return ZMQ_REQ;
if (constant == "rep")
return ZMQ_REP;
if (constant == "dealer")
return ZMQ_DEALER;
if (constant == "router")
return ZMQ_ROUTER;
if (constant == "pair")
return ZMQ_PAIR;
if (constant == "snd-hwm") if (constant == "snd-hwm") return ZMQ_SNDHWM;
return ZMQ_SNDHWM; if (constant == "rcv-hwm") return ZMQ_RCVHWM;
if (constant == "rcv-hwm") if (constant == "snd-size") return ZMQ_SNDBUF;
return ZMQ_RCVHWM; if (constant == "rcv-size") return ZMQ_RCVBUF;
if (constant == "snd-size") if (constant == "snd-more") return ZMQ_SNDMORE;
return ZMQ_SNDBUF; if (constant == "rcv-more") return ZMQ_RCVMORE;
if (constant == "rcv-size")
return ZMQ_RCVBUF;
if (constant == "snd-more")
return ZMQ_SNDMORE;
if (constant == "rcv-more")
return ZMQ_RCVMORE;
if (constant == "linger") if (constant == "linger") return ZMQ_LINGER;
return ZMQ_LINGER;
return -1; return -1;
} }

34
fairmq/zeromq/FairMQSocketZMQ.h
View File

@ -28,23 +28,23 @@ class FairMQSocketZMQ : public FairMQSocket
bool Bind(const std::string& address) override; bool Bind(const std::string& address) override;
void Connect(const std::string& address) override; void Connect(const std::string& address) override;
int Send(FairMQMessagePtr& msg) override; int Send(FairMQMessagePtr& msg, const int timeout = 0) override;
int SendAsync(FairMQMessagePtr& msg) override; int Receive(FairMQMessagePtr& msg, const int timeout = 0) override;
int Receive(FairMQMessagePtr& msg) override; int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
int ReceiveAsync(FairMQMessagePtr& msg) override; int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int TrySend(FairMQMessagePtr& msg) override;
int64_t SendAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int TryReceive(FairMQMessagePtr& msg) override;
int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
int64_t ReceiveAsync(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override; int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
void* GetSocket() const override; void* GetSocket() const override;
int GetSocket(int nothing) const override; int GetSocket(int nothing) const override;
void Close() override; void Close() override;
void Interrupt() override; static void Interrupt();
void Resume() override; static void Resume();
void SetOption(const std::string& option, const void* value, size_t valueSize) override; void SetOption(const std::string& option, const void* value, size_t valueSize) override;
void GetOption(const std::string& option, void* value, size_t* valueSize) override; void GetOption(const std::string& option, void* value, size_t* valueSize) override;
@ -61,7 +61,7 @@ class FairMQSocketZMQ : public FairMQSocket
static int GetConstant(const std::string& constant); static int GetConstant(const std::string& constant);
virtual ~FairMQSocketZMQ(); ~FairMQSocketZMQ() override;
private: private:
void* fSocket; void* fSocket;
@ -73,10 +73,14 @@ class FairMQSocketZMQ : public FairMQSocket
static std::atomic<bool> fInterrupted; static std::atomic<bool> fInterrupted;
int Send(FairMQMessagePtr& msg, const int flags = 0); int fSndTimeout;
int Receive(FairMQMessagePtr& msg, const int flags = 0); int fRcvTimeout;
int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags = 0);
int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags = 0); int SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
int ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
int64_t SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
int64_t ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
}; };
#endif /* FAIRMQSOCKETZMQ_H_ */ #endif /* FAIRMQSOCKETZMQ_H_ */

4
fairmq/zeromq/FairMQTransportFactoryZMQ.h
View File

@ -49,6 +49,10 @@ class FairMQTransportFactoryZMQ : public FairMQTransportFactory
FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const override; FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const override;
FairMQ::Transport GetType() const override; FairMQ::Transport GetType() const override;
void Interrupt() override { FairMQSocketZMQ::Interrupt(); }
void Resume() override { FairMQSocketZMQ::Resume(); }
private: private:
static FairMQ::Transport fTransportType; static FairMQ::Transport fTransportType;
void* fContext; void* fContext;