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

use factory for sockets

Browse Source
This commit is contained in:
Alexey Rybalchenko 2014-01-21 15:57:59 +01:00
parent a383434c45
commit 88fee245b8
38 changed files with 653 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
fairmq/CMakeLists.txt
View File

@ -7,6 +7,13 @@ include_directories(
${ROOT_INCLUDE_DIR} ${ROOT_INCLUDE_DIR}
) )
Set(LINK_DIRECTORIES
${ROOT_LIBRARY_DIR}
${Boost_LIBRARY_DIRS}
)
link_directories(${LINK_DIRECTORIES})
Set(SRCS Set(SRCS
"FairMQSampler.cxx" "FairMQSampler.cxx"
"FairMQBenchmarkSampler.cxx" "FairMQBenchmarkSampler.cxx"
@ -17,6 +24,8 @@ Set(SRCS
"FairMQLogger.cxx" "FairMQLogger.cxx"
"FairMQContext.cxx" "FairMQContext.cxx"
"FairMQMessage.cxx" "FairMQMessage.cxx"
"FairMQTransportFactory.cxx"
"FairMQTransportFactoryZMQ.cxx"
"FairMQMessageZMQ.cxx" "FairMQMessageZMQ.cxx"
"FairMQMessageNN.cxx" "FairMQMessageNN.cxx"
"FairMQSocket.cxx" "FairMQSocket.cxx"
@ -31,15 +40,8 @@ Set(SRCS
"FairMQProxy.cxx" "FairMQProxy.cxx"
) )
Set(LINK_DIRECTORIES
${ROOT_LIBRARY_DIR}
${Boost_LIBRARY_DIRS}
)
link_directories(${LINK_DIRECTORIES})
Set(LIBRARY_NAME FairMQ) Set(LIBRARY_NAME FairMQ)
Set(LINKDEF)
Set(DEPENDENCIES Set(DEPENDENCIES
${CMAKE_THREAD_LIBS_INIT} ${CMAKE_THREAD_LIBS_INIT}
${ZMQ_LIBRARY_SHARED} ${ZMQ_LIBRARY_SHARED}

36
fairmq/FairMQBenchmarkSampler.cxx
View File

@ -39,19 +39,21 @@ void FairMQBenchmarkSampler::Run()
boost::thread resetEventCounter(boost::bind(&FairMQBenchmarkSampler::ResetEventCounter, this)); boost::thread resetEventCounter(boost::bind(&FairMQBenchmarkSampler::ResetEventCounter, this));
void* buffer = operator new[](fEventSize); void* buffer = operator new[](fEventSize);
FairMQMessage* base_event = new FairMQMessage(buffer, fEventSize); FairMQMessage* base_event = new FairMQMessageZMQ(buffer, fEventSize);
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
FairMQMessage event; FairMQMessage* event = new FairMQMessageZMQ();
event.Copy(base_event); event->Copy(base_event);
fPayloadOutputs->at(0)->Send(&event); fPayloadOutputs->at(0)->Send(event);
--fEventCounter; --fEventCounter;
while (fEventCounter == 0) { while (fEventCounter == 0) {
boost::this_thread::sleep(boost::posix_time::milliseconds(1)); boost::this_thread::sleep(boost::posix_time::milliseconds(1));
} }
delete event;
} }
delete base_event; delete base_event;
@ -75,16 +77,16 @@ void FairMQBenchmarkSampler::ResetEventCounter()
} }
} }
void FairMQBenchmarkSampler::Log(Int_t intervalInMs) void FairMQBenchmarkSampler::Log(int intervalInMs)
{ {
timestamp_t t0; timestamp_t t0;
timestamp_t t1; timestamp_t t1;
ULong_t bytes = fPayloadOutputs->at(0)->GetBytesTx(); unsigned long bytes = fPayloadOutputs->at(0)->GetBytesTx();
ULong_t messages = fPayloadOutputs->at(0)->GetMessagesTx(); unsigned long messages = fPayloadOutputs->at(0)->GetMessagesTx();
ULong_t bytesNew; unsigned long bytesNew = 0;
ULong_t messagesNew; unsigned long messagesNew = 0;
Double_t megabytesPerSecond = (bytesNew - bytes) / (1024 * 1024); double megabytesPerSecond = 0;
Double_t messagesPerSecond = (messagesNew - messages); double messagesPerSecond = 0;
t0 = get_timestamp(); t0 = get_timestamp();
@ -98,8 +100,8 @@ void FairMQBenchmarkSampler::Log(Int_t intervalInMs)
timestamp_t timeSinceLastLog_ms = (t1 - t0) / 1000.0L; timestamp_t timeSinceLastLog_ms = (t1 - t0) / 1000.0L;
megabytesPerSecond = ((Double_t) (bytesNew - bytes) / (1024. * 1024.)) / (Double_t) timeSinceLastLog_ms * 1000.; megabytesPerSecond = ((double) (bytesNew - bytes) / (1024. * 1024.)) / (double) timeSinceLastLog_ms * 1000.;
messagesPerSecond = (Double_t) (messagesNew - messages) / (Double_t) timeSinceLastLog_ms * 1000.; messagesPerSecond = (double) (messagesNew - messages) / (double) timeSinceLastLog_ms * 1000.;
std::stringstream logmsg; std::stringstream logmsg;
logmsg << "send " << messagesPerSecond << " msg/s, " << megabytesPerSecond << " MB/s"; logmsg << "send " << messagesPerSecond << " msg/s, " << megabytesPerSecond << " MB/s";
@ -111,7 +113,7 @@ void FairMQBenchmarkSampler::Log(Int_t intervalInMs)
} }
} }
void FairMQBenchmarkSampler::SetProperty(const Int_t& key, const TString& value, const Int_t& slot/*= 0*/) void FairMQBenchmarkSampler::SetProperty(const int& key, const std::string& value, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
default: default:
@ -120,7 +122,7 @@ void FairMQBenchmarkSampler::SetProperty(const Int_t& key, const TString& value,
} }
} }
TString FairMQBenchmarkSampler::GetProperty(const Int_t& key, const TString& default_/*= ""*/, const Int_t& slot/*= 0*/) std::string FairMQBenchmarkSampler::GetProperty(const int& key, const std::string& default_/*= ""*/, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
default: default:
@ -128,7 +130,7 @@ TString FairMQBenchmarkSampler::GetProperty(const Int_t& key, const TString& def
} }
} }
void FairMQBenchmarkSampler::SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot/*= 0*/) void FairMQBenchmarkSampler::SetProperty(const int& key, const int& value, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case EventSize: case EventSize:
@ -143,7 +145,7 @@ void FairMQBenchmarkSampler::SetProperty(const Int_t& key, const Int_t& value, c
} }
} }
Int_t FairMQBenchmarkSampler::GetProperty(const Int_t& key, const Int_t& default_/*= 0*/, const Int_t& slot/*= 0*/) int FairMQBenchmarkSampler::GetProperty(const int& key, const int& default_/*= 0*/, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case EventSize: case EventSize:

17
fairmq/FairMQBenchmarkSampler.h
View File

@ -11,7 +11,6 @@
#include <string> #include <string>
#include "FairMQDevice.h" #include "FairMQDevice.h"
#include "TString.h"
/** /**
* Sampler to generate traffic for benchmarking. * Sampler to generate traffic for benchmarking.
@ -28,16 +27,16 @@ class FairMQBenchmarkSampler: public FairMQDevice
}; };
FairMQBenchmarkSampler(); FairMQBenchmarkSampler();
virtual ~FairMQBenchmarkSampler(); virtual ~FairMQBenchmarkSampler();
void Log(Int_t intervalInMs); void Log(int intervalInMs);
void ResetEventCounter(); void ResetEventCounter();
virtual void SetProperty(const Int_t& key, const TString& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const std::string& value, const int& slot = 0);
virtual TString GetProperty(const Int_t& key, const TString& default_ = "", const Int_t& slot = 0); virtual std::string GetProperty(const int& key, const std::string& default_ = "", const int& slot = 0);
virtual void SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const int& value, const int& slot = 0);
virtual Int_t GetProperty(const Int_t& key, const Int_t& default_ = 0, const Int_t& slot = 0); virtual int GetProperty(const int& key, const int& default_ = 0, const int& slot = 0);
protected: protected:
Int_t fEventSize; int fEventSize;
Int_t fEventRate; int fEventRate;
Int_t fEventCounter; int fEventCounter;
virtual void Init(); virtual void Init();
virtual void Run(); virtual void Run();
}; };

8
fairmq/FairMQBuffer.cxx
View File

@ -26,14 +26,16 @@ void FairMQBuffer::Run()
bool received = false; bool received = false;
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
received = fPayloadInputs->at(0)->Receive(&msg); received = fPayloadInputs->at(0)->Receive(msg);
if (received) { if (received) {
fPayloadOutputs->at(0)->Send(&msg); fPayloadOutputs->at(0)->Send(msg);
received = false; received = false;
} }
delete msg;
} }
rateLogger.interrupt(); rateLogger.interrupt();

8
fairmq/FairMQConfigurable.cxx
View File

@ -12,20 +12,20 @@ FairMQConfigurable::FairMQConfigurable()
{ {
} }
void FairMQConfigurable::SetProperty(const Int_t& key, const TString& value, const Int_t& slot/*= 0*/) void FairMQConfigurable::SetProperty(const int& key, const std::string& value, const int& slot/*= 0*/)
{ {
} }
TString FairMQConfigurable::GetProperty(const Int_t& key, const TString& default_/*= ""*/, const Int_t& slot/*= 0*/) std::string FairMQConfigurable::GetProperty(const int& key, const std::string& default_/*= ""*/, const int& slot/*= 0*/)
{ {
return default_; return default_;
} }
void FairMQConfigurable::SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot/*= 0*/) void FairMQConfigurable::SetProperty(const int& key, const int& value, const int& slot/*= 0*/)
{ {
} }
Int_t FairMQConfigurable::GetProperty(const Int_t& key, const Int_t& default_/*= 0*/, const Int_t& slot/*= 0*/) int FairMQConfigurable::GetProperty(const int& key, const int& default_/*= 0*/, const int& slot/*= 0*/)
{ {
return default_; return default_;
} }

11
fairmq/FairMQConfigurable.h
View File

@ -8,8 +8,7 @@
#ifndef FAIRMQCONFIGURABLE_H_ #ifndef FAIRMQCONFIGURABLE_H_
#define FAIRMQCONFIGURABLE_H_ #define FAIRMQCONFIGURABLE_H_
#include "Rtypes.h" #include <string>
#include "TString.h"
class FairMQConfigurable class FairMQConfigurable
@ -19,10 +18,10 @@ class FairMQConfigurable
Last = 1 Last = 1
}; };
FairMQConfigurable(); FairMQConfigurable();
virtual void SetProperty(const Int_t& key, const TString& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const std::string& value, const int& slot = 0);
virtual TString GetProperty(const Int_t& key, const TString& default_ = "", const Int_t& slot = 0); virtual std::string GetProperty(const int& key, const std::string& default_ = "", const int& slot = 0);
virtual void SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const int& value, const int& slot = 0);
virtual Int_t GetProperty(const Int_t& key, const Int_t& default_ = 0, const Int_t& slot = 0); virtual int GetProperty(const int& key, const int& default_ = 0, const int& slot = 0);
virtual ~FairMQConfigurable(); virtual ~FairMQConfigurable();
}; };

85
fairmq/FairMQDevice.cxx
View File

@ -9,7 +9,7 @@
#include <boost/thread.hpp> #include <boost/thread.hpp>
#include "FairMQSocket.h" #include "FairMQSocketZMQ.h"
#include "FairMQDevice.h" #include "FairMQDevice.h"
#include "FairMQLogger.h" #include "FairMQLogger.h"
@ -32,26 +32,26 @@ void FairMQDevice::Init()
fPayloadContext = new FairMQContext(fNumIoThreads); fPayloadContext = new FairMQContext(fNumIoThreads);
fInputAddress = new std::vector<TString>(fNumInputs); fInputAddress = new std::vector<std::string>(fNumInputs);
fInputMethod = new std::vector<TString>(); fInputMethod = new std::vector<std::string>();
fInputSocketType = new std::vector<Int_t>(); fInputSocketType = new std::vector<int>();
fInputSndBufSize = new std::vector<Int_t>(); fInputSndBufSize = new std::vector<int>();
fInputRcvBufSize = new std::vector<Int_t>(); fInputRcvBufSize = new std::vector<int>();
for (Int_t i = 0; i < fNumInputs; ++i) { for (int i = 0; i < fNumInputs; ++i) {
fInputMethod->push_back("connect"); // default value, can be overwritten in configuration fInputMethod->push_back("connect"); // default value, can be overwritten in configuration
fInputSocketType->push_back(ZMQ_SUB); // default value, can be overwritten in configuration fInputSocketType->push_back(ZMQ_SUB); // default value, can be overwritten in configuration
fInputSndBufSize->push_back(10000); // default value, can be overwritten in configuration fInputSndBufSize->push_back(10000); // default value, can be overwritten in configuration
fInputRcvBufSize->push_back(10000); // default value, can be overwritten in configuration fInputRcvBufSize->push_back(10000); // default value, can be overwritten in configuration
} }
fOutputAddress = new std::vector<TString>(fNumOutputs); fOutputAddress = new std::vector<std::string>(fNumOutputs);
fOutputMethod = new std::vector<TString>(); fOutputMethod = new std::vector<std::string>();
fOutputSocketType = new std::vector<Int_t>(); fOutputSocketType = new std::vector<int>();
fOutputSndBufSize = new std::vector<Int_t>(); fOutputSndBufSize = new std::vector<int>();
fOutputRcvBufSize = new std::vector<Int_t>(); fOutputRcvBufSize = new std::vector<int>();
for (Int_t i = 0; i < fNumOutputs; ++i) { for (int i = 0; i < fNumOutputs; ++i) {
fOutputMethod->push_back("bind"); // default value, can be overwritten in configuration fOutputMethod->push_back("bind"); // default value, can be overwritten in configuration
fOutputSocketType->push_back(ZMQ_PUB); // default value, can be overwritten in configuration fOutputSocketType->push_back(ZMQ_PUB); // default value, can be overwritten in configuration
fOutputSndBufSize->push_back(10000); // default value, can be overwritten in configuration fOutputSndBufSize->push_back(10000); // default value, can be overwritten in configuration
@ -63,8 +63,9 @@ void FairMQDevice::InitInput()
{ {
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, ">>>>>>> InitInput <<<<<<<"); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, ">>>>>>> InitInput <<<<<<<");
for (Int_t i = 0; i < fNumInputs; ++i) { for (int i = 0; i < fNumInputs; ++i) {
FairMQSocket* socket = new FairMQSocket(fPayloadContext, fInputSocketType->at(i), i); //FairMQSocket* socket = new FairMQSocketZMQ(fPayloadContext, fInputSocketType->at(i), i);
FairMQSocket* socket = fTransportFactory->CreateSocket(fPayloadContext, fInputSocketType->at(i), i);
socket->SetOption(ZMQ_SNDHWM, &fInputSndBufSize->at(i), sizeof(fInputSndBufSize->at(i))); socket->SetOption(ZMQ_SNDHWM, &fInputSndBufSize->at(i), sizeof(fInputSndBufSize->at(i)));
socket->SetOption(ZMQ_RCVHWM, &fInputRcvBufSize->at(i), sizeof(fInputRcvBufSize->at(i))); socket->SetOption(ZMQ_RCVHWM, &fInputRcvBufSize->at(i), sizeof(fInputRcvBufSize->at(i)));
@ -86,11 +87,14 @@ void FairMQDevice::InitOutput()
{ {
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, ">>>>>>> InitOutput <<<<<<<"); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, ">>>>>>> InitOutput <<<<<<<");
for (Int_t i = 0; i < fNumOutputs; ++i) { for (int i = 0; i < fNumOutputs; ++i) {
FairMQSocket* socket = new FairMQSocket(fPayloadContext, fOutputSocketType->at(i), i); FairMQSocket* socket = fTransportFactory->CreateSocket(fPayloadContext, fOutputSocketType->at(i), i);
socket->SetOption(ZMQ_SNDHWM, &fOutputSndBufSize->at(i), sizeof(fOutputSndBufSize->at(i))); socket->SetOption(ZMQ_SNDHWM, &fOutputSndBufSize->at(i), sizeof(fOutputSndBufSize->at(i)));
socket->SetOption(ZMQ_RCVHWM, &fOutputRcvBufSize->at(i), sizeof(fOutputRcvBufSize->at(i))); socket->SetOption(ZMQ_RCVHWM, &fOutputRcvBufSize->at(i), sizeof(fOutputRcvBufSize->at(i)));
fPayloadOutputs->push_back(socket); fPayloadOutputs->push_back(socket);
try { try {
if (fOutputMethod->at(i) == "bind") { if (fOutputMethod->at(i) == "bind") {
fPayloadOutputs->at(i)->Bind(fOutputAddress->at(i)); fPayloadOutputs->at(i)->Bind(fOutputAddress->at(i));
@ -111,7 +115,7 @@ void FairMQDevice::Pause()
} }
// Method for setting properties represented as a string. // Method for setting properties represented as a string.
void FairMQDevice::SetProperty(const Int_t& key, const TString& value, const Int_t& slot/*= 0*/) void FairMQDevice::SetProperty(const int& key, const std::string& value, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case Id: case Id:
@ -140,7 +144,7 @@ void FairMQDevice::SetProperty(const Int_t& key, const TString& value, const Int
} }
// Method for setting properties represented as an integer. // Method for setting properties represented as an integer.
void FairMQDevice::SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot/*= 0*/) void FairMQDevice::SetProperty(const int& key, const int& value, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case NumIoThreads: case NumIoThreads:
@ -186,7 +190,7 @@ void FairMQDevice::SetProperty(const Int_t& key, const Int_t& value, const Int_t
} }
// Method for getting properties represented as an string. // Method for getting properties represented as an string.
TString FairMQDevice::GetProperty(const Int_t& key, const TString& default_/*= ""*/, const Int_t& slot/*= 0*/) std::string FairMQDevice::GetProperty(const int& key, const std::string& default_/*= ""*/, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case Id: case Id:
@ -205,7 +209,7 @@ TString FairMQDevice::GetProperty(const Int_t& key, const TString& default_/*= "
} }
// Method for getting properties represented as an integer. // Method for getting properties represented as an integer.
Int_t FairMQDevice::GetProperty(const Int_t& key, const Int_t& default_/*= 0*/, const Int_t& slot/*= 0*/) int FairMQDevice::GetProperty(const int& key, const int& default_/*= 0*/, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case NumIoThreads: case NumIoThreads:
@ -229,6 +233,11 @@ Int_t FairMQDevice::GetProperty(const Int_t& key, const Int_t& default_/*= 0*/,
} }
} }
void FairMQDevice::SetTransport(FairMQTransportFactory* factory)
{
fTransportFactory = factory;
}
void FairMQDevice::LogSocketRates() void FairMQDevice::LogSocketRates()
{ {
timestamp_t t0; timestamp_t t0;
@ -236,20 +245,20 @@ void FairMQDevice::LogSocketRates()
timestamp_t timeSinceLastLog_ms; timestamp_t timeSinceLastLog_ms;
ULong_t* bytesInput = new ULong_t[fNumInputs]; unsigned long* bytesInput = new unsigned long[fNumInputs];
ULong_t* messagesInput = new ULong_t[fNumInputs]; unsigned long* messagesInput = new unsigned long[fNumInputs];
ULong_t* bytesOutput = new ULong_t[fNumOutputs]; unsigned long* bytesOutput = new unsigned long[fNumOutputs];
ULong_t* messagesOutput = new ULong_t[fNumOutputs]; unsigned long* messagesOutput = new unsigned long[fNumOutputs];
ULong_t* bytesInputNew = new ULong_t[fNumInputs]; unsigned long* bytesInputNew = new unsigned long[fNumInputs];
ULong_t* messagesInputNew = new ULong_t[fNumInputs]; unsigned long* messagesInputNew = new unsigned long[fNumInputs];
ULong_t* bytesOutputNew = new ULong_t[fNumOutputs]; unsigned long* bytesOutputNew = new unsigned long[fNumOutputs];
ULong_t* messagesOutputNew = new ULong_t[fNumOutputs]; unsigned long* messagesOutputNew = new unsigned long[fNumOutputs];
Double_t* megabytesPerSecondInput = new Double_t[fNumInputs]; double* megabytesPerSecondInput = new double[fNumInputs];
Double_t* messagesPerSecondInput = new Double_t[fNumInputs]; double* messagesPerSecondInput = new double[fNumInputs];
Double_t* megabytesPerSecondOutput = new Double_t[fNumOutputs]; double* megabytesPerSecondOutput = new double[fNumOutputs];
Double_t* messagesPerSecondOutput = new Double_t[fNumOutputs]; double* messagesPerSecondOutput = new double[fNumOutputs];
// Temp stuff for process termination // Temp stuff for process termination
bool receivedSomething = false; bool receivedSomething = false;
@ -258,7 +267,7 @@ void FairMQDevice::LogSocketRates()
int didNotSendFor = 0; int didNotSendFor = 0;
// End of temp stuff // End of temp stuff
Int_t i = 0; int i = 0;
for ( std::vector<FairMQSocket*>::iterator itr = fPayloadInputs->begin(); itr != fPayloadInputs->end(); itr++ ) { for ( std::vector<FairMQSocket*>::iterator itr = fPayloadInputs->begin(); itr != fPayloadInputs->end(); itr++ ) {
bytesInput[i] = (*itr)->GetBytesRx(); bytesInput[i] = (*itr)->GetBytesRx();
messagesInput[i] = (*itr)->GetMessagesRx(); messagesInput[i] = (*itr)->GetMessagesRx();
@ -286,10 +295,10 @@ void FairMQDevice::LogSocketRates()
for ( std::vector<FairMQSocket*>::iterator itr = fPayloadInputs->begin(); itr != fPayloadInputs->end(); itr++ ) { for ( std::vector<FairMQSocket*>::iterator itr = fPayloadInputs->begin(); itr != fPayloadInputs->end(); itr++ ) {
bytesInputNew[i] = (*itr)->GetBytesRx(); bytesInputNew[i] = (*itr)->GetBytesRx();
megabytesPerSecondInput[i] = ((Double_t) (bytesInputNew[i] - bytesInput[i]) / (1024. * 1024.)) / (Double_t) timeSinceLastLog_ms * 1000.; megabytesPerSecondInput[i] = ((double) (bytesInputNew[i] - bytesInput[i]) / (1024. * 1024.)) / (double) timeSinceLastLog_ms * 1000.;
bytesInput[i] = bytesInputNew[i]; bytesInput[i] = bytesInputNew[i];
messagesInputNew[i] = (*itr)->GetMessagesRx(); messagesInputNew[i] = (*itr)->GetMessagesRx();
messagesPerSecondInput[i] = (Double_t) (messagesInputNew[i] - messagesInput[i]) / (Double_t) timeSinceLastLog_ms * 1000.; messagesPerSecondInput[i] = (double) (messagesInputNew[i] - messagesInput[i]) / (double) timeSinceLastLog_ms * 1000.;
messagesInput[i] = messagesInputNew[i]; messagesInput[i] = messagesInputNew[i];
std::stringstream logmsg; std::stringstream logmsg;
@ -314,10 +323,10 @@ void FairMQDevice::LogSocketRates()
for ( std::vector<FairMQSocket*>::iterator itr = fPayloadOutputs->begin(); itr != fPayloadOutputs->end(); itr++ ) { for ( std::vector<FairMQSocket*>::iterator itr = fPayloadOutputs->begin(); itr != fPayloadOutputs->end(); itr++ ) {
bytesOutputNew[i] = (*itr)->GetBytesTx(); bytesOutputNew[i] = (*itr)->GetBytesTx();
megabytesPerSecondOutput[i] = ((Double_t) (bytesOutputNew[i] - bytesOutput[i]) / (1024. * 1024.)) / (Double_t) timeSinceLastLog_ms * 1000.; megabytesPerSecondOutput[i] = ((double) (bytesOutputNew[i] - bytesOutput[i]) / (1024. * 1024.)) / (double) timeSinceLastLog_ms * 1000.;
bytesOutput[i] = bytesOutputNew[i]; bytesOutput[i] = bytesOutputNew[i];
messagesOutputNew[i] = (*itr)->GetMessagesTx(); messagesOutputNew[i] = (*itr)->GetMessagesTx();
messagesPerSecondOutput[i] = (Double_t) (messagesOutputNew[i] - messagesOutput[i]) / (Double_t) timeSinceLastLog_ms * 1000.; messagesPerSecondOutput[i] = (double) (messagesOutputNew[i] - messagesOutput[i]) / (double) timeSinceLastLog_ms * 1000.;
messagesOutput[i] = messagesOutputNew[i]; messagesOutput[i] = messagesOutputNew[i];
std::stringstream logmsg; std::stringstream logmsg;

48
fairmq/FairMQDevice.h
View File

@ -8,13 +8,14 @@
#ifndef FAIRMQDEVICE_H_ #ifndef FAIRMQDEVICE_H_
#define FAIRMQDEVICE_H_ #define FAIRMQDEVICE_H_
#include <vector>
#include <string>
#include "FairMQConfigurable.h" #include "FairMQConfigurable.h"
#include "FairMQStateMachine.h" #include "FairMQStateMachine.h"
#include <vector> #include "FairMQTransportFactory.h"
#include "FairMQContext.h" #include "FairMQContext.h"
#include "FairMQSocket.h" #include "FairMQSocket.h"
#include "Rtypes.h"
#include "TString.h"
class FairMQDevice : public FairMQStateMachine, public FairMQConfigurable class FairMQDevice : public FairMQStateMachine, public FairMQConfigurable
@ -44,37 +45,40 @@ class FairMQDevice : public FairMQStateMachine, public FairMQConfigurable
virtual void LogSocketRates(); virtual void LogSocketRates();
virtual void ListenToCommands(); virtual void ListenToCommands();
virtual void SetProperty(const Int_t& key, const TString& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const std::string& value, const int& slot = 0);
virtual TString GetProperty(const Int_t& key, const TString& default_ = "", const Int_t& slot = 0); virtual std::string GetProperty(const int& key, const std::string& default_ = "", const int& slot = 0);
virtual void SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const int& value, const int& slot = 0);
virtual Int_t GetProperty(const Int_t& key, const Int_t& default_ = 0, const Int_t& slot = 0); virtual int GetProperty(const int& key, const int& default_ = 0, const int& slot = 0);
virtual void SetTransport(FairMQTransportFactory* factory);
virtual ~FairMQDevice(); virtual ~FairMQDevice();
protected: protected:
TString fId; std::string fId;
Int_t fNumIoThreads; int fNumIoThreads;
FairMQContext* fPayloadContext; FairMQContext* fPayloadContext;
FairMQTransportFactory* fTransportFactory;
Int_t fNumInputs; int fNumInputs;
Int_t fNumOutputs; int fNumOutputs;
std::vector<TString> *fInputAddress; std::vector<std::string> *fInputAddress;
std::vector<TString> *fInputMethod; std::vector<std::string> *fInputMethod;
std::vector<Int_t> *fInputSocketType; std::vector<int> *fInputSocketType;
std::vector<Int_t> *fInputSndBufSize; std::vector<int> *fInputSndBufSize;
std::vector<Int_t> *fInputRcvBufSize; std::vector<int> *fInputRcvBufSize;
std::vector<TString> *fOutputAddress; std::vector<std::string> *fOutputAddress;
std::vector<TString> *fOutputMethod; std::vector<std::string> *fOutputMethod;
std::vector<Int_t> *fOutputSocketType; std::vector<int> *fOutputSocketType;
std::vector<Int_t> *fOutputSndBufSize; std::vector<int> *fOutputSndBufSize;
std::vector<Int_t> *fOutputRcvBufSize; std::vector<int> *fOutputRcvBufSize;
std::vector<FairMQSocket*> *fPayloadInputs; std::vector<FairMQSocket*> *fPayloadInputs;
std::vector<FairMQSocket*> *fPayloadOutputs; std::vector<FairMQSocket*> *fPayloadOutputs;
Int_t fLogIntervalInMs; int fLogIntervalInMs;
virtual void Init(); virtual void Init();
virtual void Run(); virtual void Run();

15
fairmq/FairMQLogger.cxx
View File

@ -5,10 +5,11 @@
* @author D. Klein, A. Rybalchenko * @author D. Klein, A. Rybalchenko
*/ */
#include "FairMQLogger.h"
#include <iostream> #include <iostream>
#include <ctime>
#include <iomanip> #include <iomanip>
#include <ctime>
#include "FairMQLogger.h"
FairMQLogger* FairMQLogger::instance = NULL; FairMQLogger* FairMQLogger::instance = NULL;
@ -21,7 +22,7 @@ FairMQLogger* FairMQLogger::GetInstance()
return instance; return instance;
} }
FairMQLogger* FairMQLogger::InitInstance(TString bindAddress) FairMQLogger* FairMQLogger::InitInstance(std::string bindAddress)
{ {
instance = new FairMQLogger(bindAddress); instance = new FairMQLogger(bindAddress);
return instance; return instance;
@ -32,7 +33,7 @@ FairMQLogger::FairMQLogger() :
{ {
} }
FairMQLogger::FairMQLogger(TString bindAddress) : FairMQLogger::FairMQLogger(std::string bindAddress) :
fBindAddress(bindAddress) fBindAddress(bindAddress)
{ {
} }
@ -41,17 +42,17 @@ FairMQLogger::~FairMQLogger()
{ {
} }
void FairMQLogger::Log(Int_t type, TString logmsg) void FairMQLogger::Log(int type, std::string logmsg)
{ {
timestamp_t tm = get_timestamp(); timestamp_t tm = get_timestamp();
timestamp_t ms = tm / 1000.0L; timestamp_t ms = tm / 1000.0L;
timestamp_t s = ms / 1000.0L; timestamp_t s = ms / 1000.0L;
std::time_t t = s; std::time_t t = s;
std::size_t fractional_seconds = ms % 1000; std::size_t fractional_seconds = ms % 1000;
Text_t mbstr[100]; char mbstr[100];
std::strftime(mbstr, 100, "%H:%M:%S:", std::localtime(&t)); std::strftime(mbstr, 100, "%H:%M:%S:", std::localtime(&t));
TString type_str; std::string type_str;
switch (type) { switch (type) {
case DEBUG: case DEBUG:
type_str = "\033[01;34mDEBUG\033[0m"; type_str = "\033[01;34mDEBUG\033[0m";

11
fairmq/FairMQLogger.h
View File

@ -7,28 +7,27 @@
#ifndef FAIRMQLOGGER_H_ #ifndef FAIRMQLOGGER_H_
#define FAIRMQLOGGER_H_ #define FAIRMQLOGGER_H_
#include <string> #include <string>
#include <sstream> #include <sstream>
#include <sys/time.h> #include <sys/time.h>
#include "Rtypes.h"
#include "TString.h"
class FairMQLogger class FairMQLogger
{ {
private: private:
static FairMQLogger* instance; static FairMQLogger* instance;
TString fBindAddress; std::string fBindAddress;
public: public:
enum { enum {
DEBUG, INFO, ERROR, STATE DEBUG, INFO, ERROR, STATE
}; };
FairMQLogger(); FairMQLogger();
FairMQLogger(TString bindAdress); FairMQLogger(std::string bindAdress);
virtual ~FairMQLogger(); virtual ~FairMQLogger();
void Log(Int_t type, TString logmsg); void Log(int type, std::string logmsg);
static FairMQLogger* GetInstance(); static FairMQLogger* GetInstance();
static FairMQLogger* InitInstance(TString bindAddress); static FairMQLogger* InitInstance(std::string bindAddress);
}; };
typedef unsigned long long timestamp_t; typedef unsigned long long timestamp_t;

10
fairmq/FairMQMerger.cxx
View File

@ -35,22 +35,24 @@ void FairMQMerger::Run()
items[i].revents = 0; items[i].revents = 0;
} }
Bool_t received = false; bool received = false;
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
zmq_poll(items, fNumInputs, 100); zmq_poll(items, fNumInputs, 100);
for(int i = 0; i < fNumInputs; i++) { for(int i = 0; i < fNumInputs; i++) {
if (items[i].revents & ZMQ_POLLIN) { if (items[i].revents & ZMQ_POLLIN) {
received = fPayloadInputs->at(i)->Receive(&msg); received = fPayloadInputs->at(i)->Receive(msg);
} }
if (received) { if (received) {
fPayloadOutputs->at(0)->Send(&msg); fPayloadOutputs->at(0)->Send(msg);
received = false; received = false;
} }
} }
delete msg;
} }
rateLogger.interrupt(); rateLogger.interrupt();

93
fairmq/FairMQMessage.cxx
View File

@ -4,96 +4,3 @@
* @since 2012-12-05 * @since 2012-12-05
* @author: D. Klein, A. Rybalchenko * @author: D. Klein, A. Rybalchenko
*/ */
#include <cstdlib>
#include "FairMQMessage.h"
#include "FairMQLogger.h"
FairMQMessage::FairMQMessage()
{
int rc = zmq_msg_init (&fMessage);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed initializing message, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
FairMQMessage::FairMQMessage(size_t size)
{
int rc = zmq_msg_init_size (&fMessage, size);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed initializing message with size, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
FairMQMessage::FairMQMessage(void* data, size_t size)
{
int rc = zmq_msg_init_data (&fMessage, data, size, &CleanUp, NULL);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed initializing message with data, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
FairMQMessage::~FairMQMessage()
{
int rc = zmq_msg_close (&fMessage);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed closing message with data, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
void FairMQMessage::Rebuild(void* data, size_t size)
{
int rc = zmq_msg_close (&fMessage);
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed closing message, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
rc = zmq_msg_init_data (&fMessage, data, size, &CleanUp, NULL);
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed initializing message with data, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
zmq_msg_t* FairMQMessage::GetMessage()
{
return &fMessage;
}
void* FairMQMessage::GetData()
{
return zmq_msg_data (&fMessage);
}
size_t FairMQMessage::GetSize()
{
return zmq_msg_size (&fMessage);
}
void FairMQMessage::Copy(FairMQMessage* msg)
{
int rc = zmq_msg_copy (&fMessage, &(msg->fMessage));
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed copying message, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
void FairMQMessage::CleanUp(void* data, void* hint)
{
free (data);
}

29
fairmq/FairMQMessage.h
View File

@ -8,34 +8,23 @@
#ifndef FAIRMQMESSAGE_H_ #ifndef FAIRMQMESSAGE_H_
#define FAIRMQMESSAGE_H_ #define FAIRMQMESSAGE_H_
#include <cstddef> #include <cstddef> // for size_t
#include <zmq.h>
class FairMQMessage class FairMQMessage
{ {
public: public:
FairMQMessage(); virtual void Rebuild() = 0;
FairMQMessage(size_t size); virtual void Rebuild(size_t size) = 0;
FairMQMessage(void* data, size_t size); virtual void Rebuild(void* data, size_t site) = 0;
void Rebuild(); virtual void* GetMessage() = 0;
void Rebuild(size_t size); virtual void* GetData() = 0;
void Rebuild(void* data, size_t site); virtual size_t GetSize() = 0;
zmq_msg_t* GetMessage(); virtual void Copy(FairMQMessage* msg) = 0;
void* GetData();
size_t GetSize();
void Copy(FairMQMessage* msg); virtual ~FairMQMessage() {};
static void CleanUp(void* data, void* hint);
virtual ~FairMQMessage();
private:
zmq_msg_t fMessage;
}; };
#endif /* FAIRMQMESSAGE_H_ */ #endif /* FAIRMQMESSAGE_H_ */

111
fairmq/FairMQMessageZMQ.cxx
View File

@ -0,0 +1,111 @@
/**
* FairMQMessageZMQ.cxx
*
* @since 2012-12-05
* @author: D. Klein, A. Rybalchenko
*/
#include <cstdlib>
#include "FairMQMessageZMQ.h"
#include "FairMQLogger.h"
FairMQMessageZMQ::FairMQMessageZMQ()
{
int rc = zmq_msg_init (&fMessage);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed initializing message, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
FairMQMessageZMQ::FairMQMessageZMQ(size_t size)
{
int rc = zmq_msg_init_size (&fMessage, size);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed initializing message with size, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
FairMQMessageZMQ::FairMQMessageZMQ(void* data, size_t size)
{
int rc = zmq_msg_init_data (&fMessage, data, size, &CleanUp, NULL);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed initializing message with data, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
void FairMQMessageZMQ::Rebuild()
{
//TODO
}
void FairMQMessageZMQ::Rebuild(size_t size)
{
//TODO
}
void FairMQMessageZMQ::Rebuild(void* data, size_t size)
{
int rc = zmq_msg_close (&fMessage);
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed closing message, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
rc = zmq_msg_init_data (&fMessage, data, size, &CleanUp, NULL);
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed initializing message with data, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
void* FairMQMessageZMQ::GetMessage()
{
return &fMessage;
}
void* FairMQMessageZMQ::GetData()
{
return zmq_msg_data (&fMessage);
}
size_t FairMQMessageZMQ::GetSize()
{
return zmq_msg_size (&fMessage);
}
void FairMQMessageZMQ::Copy(FairMQMessage* msg)
{
int rc = zmq_msg_copy (&fMessage, &(static_cast<FairMQMessageZMQ*>(msg)->fMessage));
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed copying message, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
void FairMQMessageZMQ::CleanUp(void* data, void* hint)
{
free (data);
}
FairMQMessageZMQ::~FairMQMessageZMQ()
{
int rc = zmq_msg_close (&fMessage);
if (rc != 0){
std::stringstream logmsg;
logmsg << "failed closing message with data, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}

43
fairmq/FairMQMessageZMQ.h
View File

@ -0,0 +1,43 @@
/**
* FairMQMessageZMQ.h
*
* @since 2014-01-17
* @author: A. Rybalchenko
*/
#ifndef FAIRMQMESSAGEZMQ_H_
#define FAIRMQMESSAGEZMQ_H_
#include <cstddef>
#include <zmq.h>
#include "FairMQMessage.h"
class FairMQMessageZMQ: public FairMQMessage
{
public:
FairMQMessageZMQ();
FairMQMessageZMQ(size_t size);
FairMQMessageZMQ(void* data, size_t size);
virtual void Rebuild();
virtual void Rebuild(size_t size);
virtual void Rebuild(void* data, size_t site);
virtual void* GetMessage();
virtual void* GetData();
virtual size_t GetSize();
virtual void Copy(FairMQMessage* msg);
static void CleanUp(void* data, void* hint);
virtual ~FairMQMessageZMQ();
private:
zmq_msg_t fMessage;
};
#endif /* FAIRMQMESSAGEZMQ_H_ */

12
fairmq/FairMQProcessor.cxx
View File

@ -42,21 +42,23 @@ void FairMQProcessor::Run()
int receivedMsgs = 0; int receivedMsgs = 0;
int sentMsgs = 0; int sentMsgs = 0;
Bool_t received = false; bool received = false;
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
received = fPayloadInputs->at(0)->Receive(&msg); received = fPayloadInputs->at(0)->Receive(msg);
receivedMsgs++; receivedMsgs++;
if (received) { if (received) {
fTask->Exec(&msg, NULL); fTask->Exec(msg, NULL);
fPayloadOutputs->at(0)->Send(&msg); fPayloadOutputs->at(0)->Send(msg);
sentMsgs++; sentMsgs++;
received = false; received = false;
} }
delete msg;
} }
std::cout << "I've received " << receivedMsgs << " and sent " << sentMsgs << " messages!" << std::endl; std::cout << "I've received " << receivedMsgs << " and sent " << sentMsgs << " messages!" << std::endl;

1
fairmq/FairMQProcessor.h
View File

@ -10,7 +10,6 @@
#include "FairMQDevice.h" #include "FairMQDevice.h"
#include "FairMQProcessorTask.h" #include "FairMQProcessorTask.h"
#include "Rtypes.h"
class FairMQProcessor: public FairMQDevice class FairMQProcessor: public FairMQDevice

1
fairmq/FairMQProcessorTask.h
View File

@ -9,6 +9,7 @@
#define FAIRMQPROCESSORTASK_H_ #define FAIRMQPROCESSORTASK_H_
#include <vector> #include <vector>
#include "FairMQMessage.h" #include "FairMQMessage.h"
#include "FairTask.h" #include "FairTask.h"

8
fairmq/FairMQProxy.cxx
View File

@ -25,13 +25,15 @@ void FairMQProxy::Run()
boost::thread rateLogger(boost::bind(&FairMQDevice::LogSocketRates, this)); boost::thread rateLogger(boost::bind(&FairMQDevice::LogSocketRates, this));
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
fPayloadInputs->at(0)->Receive(&msg); fPayloadInputs->at(0)->Receive(msg);
fPayloadOutputs->at(0)->Send(&msg); fPayloadOutputs->at(0)->Send(msg);
} }
delete msg;
rateLogger.interrupt(); rateLogger.interrupt();
rateLogger.join(); rateLogger.join();
} }

2
fairmq/FairMQProxy.h
View File

@ -9,8 +9,6 @@
#define FAIRMQPROXY_H_ #define FAIRMQPROXY_H_
#include "FairMQDevice.h" #include "FairMQDevice.h"
#include "Rtypes.h"
#include "TString.h"
class FairMQProxy: public FairMQDevice class FairMQProxy: public FairMQDevice

16
fairmq/FairMQSampler.cxx
View File

@ -62,7 +62,7 @@ void FairMQSampler::Init()
fFairRunAna->Init(); fFairRunAna->Init();
//fFairRunAna->Run(0, 0); //fFairRunAna->Run(0, 0);
FairRootManager* ioman = FairRootManager::Instance(); FairRootManager* ioman = FairRootManager::Instance();
fNumEvents = Int_t((ioman->GetInChain())->GetEntries()); fNumEvents = int((ioman->GetInChain())->GetEntries());
} }
void FairMQSampler::Run() void FairMQSampler::Run()
@ -139,9 +139,9 @@ void FairMQSampler::ListenToCommands()
while ( true ) { while ( true ) {
try { try {
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
received = fPayloadInputs->at(0)->Receive(&msg); received = fPayloadInputs->at(0)->Receive(msg);
if (received) { if (received) {
//command handling goes here. //command handling goes here.
@ -149,6 +149,8 @@ void FairMQSampler::ListenToCommands()
received = false; received = false;
} }
delete msg;
boost::this_thread::interruption_point(); boost::this_thread::interruption_point();
} catch (boost::thread_interrupted&) { } catch (boost::thread_interrupted&) {
std::cout << "commandListener interrupted" << std::endl; std::cout << "commandListener interrupted" << std::endl;
@ -158,7 +160,7 @@ void FairMQSampler::ListenToCommands()
FairMQLogger::GetInstance()->Log(FairMQLogger::DEBUG, ">>>>>>> stopping commandListener <<<<<<<"); FairMQLogger::GetInstance()->Log(FairMQLogger::DEBUG, ">>>>>>> stopping commandListener <<<<<<<");
} }
void FairMQSampler::SetProperty(const Int_t& key, const TString& value, const Int_t& slot/*= 0*/) void FairMQSampler::SetProperty(const int& key, const std::string& value, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case InputFile: case InputFile:
@ -176,7 +178,7 @@ void FairMQSampler::SetProperty(const Int_t& key, const TString& value, const In
} }
} }
TString FairMQSampler::GetProperty(const Int_t& key, const TString& default_/*= ""*/, const Int_t& slot/*= 0*/) std::string FairMQSampler::GetProperty(const int& key, const std::string& default_/*= ""*/, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case InputFile: case InputFile:
@ -190,7 +192,7 @@ TString FairMQSampler::GetProperty(const Int_t& key, const TString& default_/*=
} }
} }
void FairMQSampler::SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot/*= 0*/) void FairMQSampler::SetProperty(const int& key, const int& value, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case EventRate: case EventRate:
@ -202,7 +204,7 @@ void FairMQSampler::SetProperty(const Int_t& key, const Int_t& value, const Int_
} }
} }
Int_t FairMQSampler::GetProperty(const Int_t& key, const Int_t& default_/*= 0*/, const Int_t& slot/*= 0*/) int FairMQSampler::GetProperty(const int& key, const int& default_/*= 0*/, const int& slot/*= 0*/)
{ {
switch (key) { switch (key) {
case EventRate: case EventRate:

21
fairmq/FairMQSampler.h
View File

@ -13,7 +13,6 @@
#include "FairTask.h" #include "FairTask.h"
#include "FairMQDevice.h" #include "FairMQDevice.h"
#include "FairMQSamplerTask.h" #include "FairMQSamplerTask.h"
#include "TString.h"
/** /**
@ -41,19 +40,19 @@ class FairMQSampler: public FairMQDevice
void ResetEventCounter(); void ResetEventCounter();
virtual void ListenToCommands(); virtual void ListenToCommands();
virtual void SetProperty(const Int_t& key, const TString& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const std::string& value, const int& slot = 0);
virtual TString GetProperty(const Int_t& key, const TString& default_ = "", const Int_t& slot = 0); virtual std::string GetProperty(const int& key, const std::string& default_ = "", const int& slot = 0);
virtual void SetProperty(const Int_t& key, const Int_t& value, const Int_t& slot = 0); virtual void SetProperty(const int& key, const int& value, const int& slot = 0);
virtual Int_t GetProperty(const Int_t& key, const Int_t& default_ = 0, const Int_t& slot = 0); virtual int GetProperty(const int& key, const int& default_ = 0, const int& slot = 0);
protected: protected:
FairRunAna* fFairRunAna; FairRunAna* fFairRunAna;
Int_t fNumEvents; int fNumEvents;
FairMQSamplerTask* fSamplerTask; FairMQSamplerTask* fSamplerTask;
TString fInputFile; // Filename of a root file containing the simulated digis. std::string fInputFile; // Filename of a root file containing the simulated digis.
TString fParFile; std::string fParFile;
TString fBranch; // The name of the sub-detector branch to stream the digis from. std::string fBranch; // The name of the sub-detector branch to stream the digis from.
Int_t fEventRate; int fEventRate;
Int_t fEventCounter; int fEventCounter;
virtual void Init(); virtual void Init();
virtual void Run(); virtual void Run();

6
fairmq/FairMQSamplerTask.cxx
View File

@ -8,11 +8,11 @@
#include "FairMQSamplerTask.h" #include "FairMQSamplerTask.h"
FairMQSamplerTask::FairMQSamplerTask(const Text_t* name, Int_t iVerbose) : FairMQSamplerTask::FairMQSamplerTask(const Text_t* name, int iVerbose) :
FairTask(name, iVerbose), FairTask(name, iVerbose),
fInput(NULL), fInput(NULL),
fBranch(""), fBranch(""),
fOutput(new FairMQMessage) fOutput(new FairMQMessageZMQ)
{ {
} }
@ -20,7 +20,7 @@ FairMQSamplerTask::FairMQSamplerTask() :
FairTask( "Abstract base task used for loading a branch from a root file into memory"), FairTask( "Abstract base task used for loading a branch from a root file into memory"),
fInput(NULL), fInput(NULL),
fBranch(""), fBranch(""),
fOutput(new FairMQMessage) fOutput(new FairMQMessageZMQ)
{ {
} }

3
fairmq/FairMQSamplerTask.h
View File

@ -13,6 +13,7 @@
#include "TClonesArray.h" #include "TClonesArray.h"
#include <string> #include <string>
#include "FairMQMessage.h" #include "FairMQMessage.h"
#include "FairMQMessageZMQ.h"
#include "TString.h" #include "TString.h"
@ -20,7 +21,7 @@ class FairMQSamplerTask: public FairTask
{ {
public: public:
FairMQSamplerTask(); FairMQSamplerTask();
FairMQSamplerTask(const Text_t* name, Int_t iVerbose=1); FairMQSamplerTask(const Text_t* name, int iVerbose=1);
virtual ~FairMQSamplerTask(); virtual ~FairMQSamplerTask();
virtual InitStatus Init(); virtual InitStatus Init();
virtual void Exec(Option_t* opt) = 0; virtual void Exec(Option_t* opt) = 0;

7
fairmq/FairMQSink.cxx
View File

@ -17,15 +17,16 @@ FairMQSink::FairMQSink()
void FairMQSink::Run() void FairMQSink::Run()
{ {
void* status; //necessary for pthread_join
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, ">>>>>>> Run <<<<<<<"); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, ">>>>>>> Run <<<<<<<");
boost::thread rateLogger(boost::bind(&FairMQDevice::LogSocketRates, this)); boost::thread rateLogger(boost::bind(&FairMQDevice::LogSocketRates, this));
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
fPayloadInputs->at(0)->Receive(&msg); fPayloadInputs->at(0)->Receive(msg);
delete msg;
} }
rateLogger.interrupt(); rateLogger.interrupt();

175
fairmq/FairMQSocket.cxx
View File

@ -4,178 +4,3 @@
* @since 2012-12-05 * @since 2012-12-05
* @author D. Klein, A. Rybalchenko * @author D. Klein, A. Rybalchenko
*/ */
#include "FairMQSocket.h"
#include <sstream>
#include "FairMQLogger.h"
FairMQSocket::FairMQSocket(FairMQContext* context, int type, int num) :
fBytesTx(0),
fBytesRx(0),
fMessagesTx(0),
fMessagesRx(0)
{
std::stringstream id;
id << GetTypeString(type) << "." << num;
fId = id.str();
fSocket = zmq_socket(context->GetContext(), type);
int rc = zmq_setsockopt(fSocket, ZMQ_IDENTITY, &fId, fId.Length());
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed setting socket option, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
if (type == ZMQ_SUB) {
rc = zmq_setsockopt(fSocket, ZMQ_SUBSCRIBE, NULL, 0);
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed setting socket option, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
std::stringstream logmsg3;
logmsg3 << "created socket #" << fId;
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg3.str());
}
FairMQSocket::~FairMQSocket()
{
}
TString FairMQSocket::GetId()
{
return fId;
}
TString FairMQSocket::GetTypeString(int type)
{
switch (type) {
case ZMQ_SUB:
return "sub";
case ZMQ_PUB:
return "pub";
case ZMQ_PUSH:
return "push";
case ZMQ_PULL:
return "pull";
default:
return "";
}
}
void FairMQSocket::Bind(TString address)
{
std::stringstream logmsg;
logmsg << "bind socket #" << fId << " on " << address;
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
int rc = zmq_bind (fSocket, address);
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed binding socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
void FairMQSocket::Connect(TString address)
{
std::stringstream logmsg;
logmsg << "connect socket #" << fId << " on " << address;
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
int rc = zmq_connect (fSocket, address);
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed connecting socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
size_t FairMQSocket::Send(FairMQMessage* msg)
{
int nbytes = zmq_msg_send (msg->GetMessage(), fSocket, 0);
if (nbytes >= 0){
fBytesTx += nbytes;
++fMessagesTx;
return nbytes;
}
if (zmq_errno() == EAGAIN){
return false;
}
std::stringstream logmsg;
logmsg << "failed sending on socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
return nbytes;
}
size_t FairMQSocket::Receive(FairMQMessage* msg)
{
int nbytes = zmq_msg_recv (msg->GetMessage(), fSocket, 0);
if (nbytes >= 0){
fBytesRx += nbytes;
++fMessagesRx;
return nbytes;
}
if (zmq_errno() == EAGAIN){
return false;
}
std::stringstream logmsg;
logmsg << "failed receiving on socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
return nbytes;
}
void FairMQSocket::SetOption(int option, const void* value, size_t valueSize)
{
int rc = zmq_setsockopt(fSocket, option, value, valueSize);
if (rc < 0) {
std::stringstream logmsg;
logmsg << "failed setting socket option, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
void FairMQSocket::Close()
{
if (fSocket == NULL){
return;
}
int rc = zmq_close (fSocket);
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed closing socket, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
fSocket = NULL;
}
void* FairMQSocket::GetSocket()
{
return fSocket;
}
ULong_t FairMQSocket::GetBytesTx()
{
return fBytesTx;
}
ULong_t FairMQSocket::GetBytesRx()
{
return fBytesRx;
}
ULong_t FairMQSocket::GetMessagesTx()
{
return fMessagesTx;
}
ULong_t FairMQSocket::GetMessagesRx()
{
return fMessagesRx;
}

42
fairmq/FairMQSocket.h
View File

@ -8,42 +8,34 @@
#ifndef FAIRMQSOCKET_H_ #ifndef FAIRMQSOCKET_H_
#define FAIRMQSOCKET_H_ #define FAIRMQSOCKET_H_
#include <zmq.h>
#include <string> #include <string>
#include "FairMQContext.h" #include "FairMQContext.h"
#include "FairMQMessage.h" #include "FairMQMessage.h"
#include "Rtypes.h" #include "FairMQMessageZMQ.h"
#include "TString.h"
class FairMQSocket class FairMQSocket
{ {
public: public:
FairMQSocket(FairMQContext* context, int type, int num); virtual std::string GetId() = 0;
virtual ~FairMQSocket();
TString GetId();
static TString GetTypeString(int type);
size_t Send(FairMQMessage* msg);
size_t Receive(FairMQMessage* msg);
void Close();
void Bind(TString address);
void Connect(TString address);
void* GetSocket();
void SetOption(int option, const void* value, size_t valueSize); virtual void Bind(std::string address) = 0;
virtual void Connect(std::string address) = 0;
ULong_t GetBytesTx(); virtual size_t Send(FairMQMessage* msg) = 0;
ULong_t GetBytesRx(); virtual size_t Receive(FairMQMessage* msg) = 0;
ULong_t GetMessagesTx();
ULong_t GetMessagesRx();
private: virtual void Close() = 0;
void* fSocket; virtual void* GetSocket() = 0;
TString fId;
ULong_t fBytesTx; virtual void SetOption(int option, const void* value, size_t valueSize) = 0;
ULong_t fBytesRx;
ULong_t fMessagesTx; virtual unsigned long GetBytesTx() = 0;
ULong_t fMessagesRx; virtual unsigned long GetBytesRx() = 0;
virtual unsigned long GetMessagesTx() = 0;
virtual unsigned long GetMessagesRx() = 0;
virtual ~FairMQSocket() {};
}; };
#endif /* FAIRMQSOCKET_H_ */ #endif /* FAIRMQSOCKET_H_ */

182
fairmq/FairMQSocketZMQ.cxx
View File

@ -0,0 +1,182 @@
/**
* FairMQSocketZMQ.cxx
*
* @since 2012-12-05
* @author D. Klein, A. Rybalchenko
*/
#include <sstream>
#include "FairMQSocketZMQ.h"
#include "FairMQLogger.h"
FairMQSocketZMQ::FairMQSocketZMQ(FairMQContext* context, int type, int num) :
fBytesTx(0),
fBytesRx(0),
fMessagesTx(0),
fMessagesRx(0)
{
std::stringstream id;
id << GetTypeString(type) << "." << num;
fId = id.str();
fSocket = zmq_socket(context->GetContext(), type);
int rc = zmq_setsockopt(fSocket, ZMQ_IDENTITY, &fId, fId.length());
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed setting socket option, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
if (type == ZMQ_SUB) {
rc = zmq_setsockopt(fSocket, ZMQ_SUBSCRIBE, NULL, 0);
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed setting socket option, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
std::stringstream logmsg3;
logmsg3 << "created socket #" << fId;
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg3.str());
}
std::string FairMQSocketZMQ::GetId()
{
return fId;
}
std::string FairMQSocketZMQ::GetTypeString(int type)
{
switch (type) {
case ZMQ_SUB:
return "sub";
case ZMQ_PUB:
return "pub";
case ZMQ_PUSH:
return "push";
case ZMQ_PULL:
return "pull";
default:
return "";
}
}
void FairMQSocketZMQ::Bind(std::string address)
{
std::stringstream logmsg;
logmsg << "bind socket #" << fId << " on " << address;
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
int rc = zmq_bind (fSocket, address.c_str());
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed binding socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
void FairMQSocketZMQ::Connect(std::string address)
{
std::stringstream logmsg;
logmsg << "connect socket #" << fId << " on " << address;
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
int rc = zmq_connect (fSocket, address.c_str());
if (rc != 0) {
std::stringstream logmsg2;
logmsg2 << "failed connecting socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
}
}
size_t FairMQSocketZMQ::Send(FairMQMessage* msg)
{
int nbytes = zmq_msg_send (static_cast<zmq_msg_t*>(msg->GetMessage()), fSocket, 0);
if (nbytes >= 0){
fBytesTx += nbytes;
++fMessagesTx;
return nbytes;
}
if (zmq_errno() == EAGAIN){
return false;
}
std::stringstream logmsg;
logmsg << "failed sending on socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
return nbytes;
}
size_t FairMQSocketZMQ::Receive(FairMQMessage* msg)
{
int nbytes = zmq_msg_recv (static_cast<zmq_msg_t*>(msg->GetMessage()), fSocket, 0);
if (nbytes >= 0){
fBytesRx += nbytes;
++fMessagesRx;
return nbytes;
}
if (zmq_errno() == EAGAIN){
return false;
}
std::stringstream logmsg;
logmsg << "failed receiving on socket #" << fId << ", reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
return nbytes;
}
void FairMQSocketZMQ::SetOption(int option, const void* value, size_t valueSize)
{
int rc = zmq_setsockopt(fSocket, option, value, valueSize);
if (rc < 0) {
std::stringstream logmsg;
logmsg << "failed setting socket option, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
}
void FairMQSocketZMQ::Close()
{
if (fSocket == NULL){
return;
}
int rc = zmq_close (fSocket);
if (rc != 0) {
std::stringstream logmsg;
logmsg << "failed closing socket, reason: " << zmq_strerror(errno);
FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
}
fSocket = NULL;
}
void* FairMQSocketZMQ::GetSocket()
{
return fSocket;
}
unsigned long FairMQSocketZMQ::GetBytesTx()
{
return fBytesTx;
}
unsigned long FairMQSocketZMQ::GetBytesRx()
{
return fBytesRx;
}
unsigned long FairMQSocketZMQ::GetMessagesTx()
{
return fMessagesTx;
}
unsigned long FairMQSocketZMQ::GetMessagesRx()
{
return fMessagesRx;
}
FairMQSocketZMQ::~FairMQSocketZMQ()
{
}

53
fairmq/FairMQSocketZMQ.h
View File

@ -0,0 +1,53 @@
/**
* FairMQSocketZMQ.h
*
* @since 2012-12-05
* @author D. Klein, A. Rybalchenko
*/
#ifndef FAIRMQSOCKETZMQ_H_
#define FAIRMQSOCKETZMQ_H_
#include <zmq.h>
#include "FairMQSocket.h"
#include "FairMQContext.h"
#include "FairMQMessageZMQ.h"
class FairMQSocketZMQ : public FairMQSocket
{
public:
FairMQSocketZMQ(FairMQContext* context, int type, int num);
virtual std::string GetId();
virtual void Bind(std::string address);
virtual void Connect(std::string address);
virtual size_t Send(FairMQMessage* msg);
virtual size_t Receive(FairMQMessage* msg);
virtual void Close();
virtual void* GetSocket();
virtual void SetOption(int option, const void* value, size_t valueSize);
virtual unsigned long GetBytesTx();
virtual unsigned long GetBytesRx();
virtual unsigned long GetMessagesTx();
virtual unsigned long GetMessagesRx();
static std::string GetTypeString(int type);
virtual ~FairMQSocketZMQ();
private:
void* fSocket;
std::string fId;
unsigned long fBytesTx;
unsigned long fBytesRx;
unsigned long fMessagesTx;
unsigned long fMessagesRx;
};
#endif /* FAIRMQSOCKETZMQ_H_ */

8
fairmq/FairMQSplitter.cxx
View File

@ -30,18 +30,20 @@ void FairMQSplitter::Run()
int direction = 0; int direction = 0;
while ( fState == RUNNING ) { while ( fState == RUNNING ) {
FairMQMessage msg; FairMQMessage* msg = new FairMQMessageZMQ();
received = fPayloadInputs->at(0)->Receive(&msg); received = fPayloadInputs->at(0)->Receive(msg);
if (received) { if (received) {
fPayloadOutputs->at(direction)->Send(&msg); fPayloadOutputs->at(direction)->Send(msg);
direction++; direction++;
if (direction >= fNumOutputs) { if (direction >= fNumOutputs) {
direction = 0; direction = 0;
} }
received = false; received = false;
} }
delete msg;
} }
rateLogger.interrupt(); rateLogger.interrupt();

4
fairmq/runBenchmarkSampler.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQBenchmarkSampler.h" #include "FairMQBenchmarkSampler.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQBenchmarkSampler sampler; FairMQBenchmarkSampler sampler;
@ -50,6 +51,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
sampler.SetTransport(transportFactory);
int i = 1; int i = 1;
sampler.SetProperty(FairMQBenchmarkSampler::Id, argv[i]); sampler.SetProperty(FairMQBenchmarkSampler::Id, argv[i]);

4
fairmq/runBuffer.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQBuffer.h" #include "FairMQBuffer.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQBuffer buffer; FairMQBuffer buffer;
@ -50,6 +51,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
buffer.SetTransport(transportFactory);
int i = 1; int i = 1;
buffer.SetProperty(FairMQBuffer::Id, argv[i]); buffer.SetProperty(FairMQBuffer::Id, argv[i]);

4
fairmq/runMerger.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQMerger.h" #include "FairMQMerger.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQMerger merger; FairMQMerger merger;
@ -51,6 +52,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
merger.SetTransport(transportFactory);
int i = 1; int i = 1;
merger.SetProperty(FairMQMerger::Id, argv[i]); merger.SetProperty(FairMQMerger::Id, argv[i]);

4
fairmq/runNToOneMerger.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQMerger.h" #include "FairMQMerger.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQMerger merger; FairMQMerger merger;
@ -53,6 +54,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
merger.SetTransport(transportFactory);
int i = 1; int i = 1;
merger.SetProperty(FairMQMerger::Id, argv[i]); merger.SetProperty(FairMQMerger::Id, argv[i]);

4
fairmq/runOneToNSplitter.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQSplitter.h" #include "FairMQSplitter.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQSplitter splitter; FairMQSplitter splitter;
@ -52,6 +53,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
splitter.SetTransport(transportFactory);
int i = 1; int i = 1;
splitter.SetProperty(FairMQSplitter::Id, argv[i]); splitter.SetProperty(FairMQSplitter::Id, argv[i]);

4
fairmq/runProxy.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQProxy.h" #include "FairMQProxy.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQProxy proxy; FairMQProxy proxy;
@ -50,6 +51,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
proxy.SetTransport(transportFactory);
int i = 1; int i = 1;
proxy.SetProperty(FairMQProxy::Id, argv[i]); proxy.SetProperty(FairMQProxy::Id, argv[i]);

4
fairmq/runSink.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQSink.h" #include "FairMQSink.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQSink sink; FairMQSink sink;
@ -50,6 +51,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
sink.SetTransport(transportFactory);
int i = 1; int i = 1;
sink.SetProperty(FairMQSink::Id, argv[i]); sink.SetProperty(FairMQSink::Id, argv[i]);

4
fairmq/runSplitter.cxx
View File

@ -10,6 +10,7 @@
#include "FairMQLogger.h" #include "FairMQLogger.h"
#include "FairMQSplitter.h" #include "FairMQSplitter.h"
#include "FairMQTransportFactoryZMQ.h"
FairMQSplitter splitter; FairMQSplitter splitter;
@ -51,6 +52,9 @@ int main(int argc, char** argv)
logmsg << "PID: " << getpid(); logmsg << "PID: " << getpid();
FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str()); FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
splitter.SetTransport(transportFactory);
int i = 1; int i = 1;
splitter.SetProperty(FairMQSplitter::Id, argv[i]); splitter.SetProperty(FairMQSplitter::Id, argv[i]);