move zeromq and nanomsg implementation files to separate directories

fairmq/zeromq/FairMQContextZMQ.cxx

@@ -0,0 +1,53 @@
+/**
+ * FairMQContextZMQ.cxx
+ *
+ * @since 2012-12-05
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include "FairMQLogger.h"
+#include "FairMQContextZMQ.h"
+#include <sstream>
+
+FairMQContextZMQ::FairMQContextZMQ(int numIoThreads)
+{
+  fContext = zmq_ctx_new ();
+  if (fContext == NULL){
+    stringstream logmsg;
+    logmsg << "failed creating context, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+
+  int rc = zmq_ctx_set (fContext, ZMQ_IO_THREADS, numIoThreads);
+  if (rc != 0){
+    stringstream logmsg;
+    logmsg << "failed configuring context, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+}
+
+FairMQContextZMQ::~FairMQContextZMQ()
+{
+  Close();
+}
+
+void* FairMQContextZMQ::GetContext()
+{
+  return fContext;
+}
+
+void FairMQContextZMQ::Close()
+{
+  if (fContext == NULL){
+    return;
+  }
+
+  int rc = zmq_ctx_destroy (fContext);
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed closing context, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+
+  fContext = NULL;
+}

fairmq/zeromq/FairMQContextZMQ.h

@@ -0,0 +1,25 @@
+/**
+ * FairMQContext.h
+ *
+ * @since 2012-12-05
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#ifndef FAIRMQCONTEXTZMQ_H_
+#define FAIRMQCONTEXTZMQ_H_
+
+#include <zmq.h>
+
+class FairMQContextZMQ
+{
+  public:
+    FairMQContextZMQ(int numIoThreads);
+    virtual ~FairMQContextZMQ();
+    void* GetContext();
+    void Close();
+
+  private:
+    void* fContext;
+};
+
+#endif /* FAIRMQCONTEXTZMQ_H_ */

fairmq/zeromq/FairMQMessageZMQ.cxx

@@ -0,0 +1,138 @@
+/**
+ * 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) {
+    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) {
+    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) {
+    stringstream logmsg;
+    logmsg << "failed initializing message with data, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+}
+
+void FairMQMessageZMQ::Rebuild()
+{
+  int rc = zmq_msg_close (&fMessage);
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed closing message, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+
+  rc = zmq_msg_init (&fMessage);
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed initializing message, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+}
+
+void FairMQMessageZMQ::Rebuild(size_t size)
+{
+  int rc = zmq_msg_close (&fMessage);
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed closing message, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+
+  rc = zmq_msg_init_size (&fMessage, size);
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed initializing message with size, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+}
+
+void FairMQMessageZMQ::Rebuild(void* data, size_t size)
+{
+  int rc = zmq_msg_close (&fMessage);
+  if (rc != 0) {
+    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) {
+    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::SetMessage(void* data, size_t size)
+{
+  // dummy method to comply with the interface. functionality not allowed in zeromq.
+}
+
+void FairMQMessageZMQ::Copy(FairMQMessage* msg)
+{
+  int rc = zmq_msg_copy (&fMessage, &(static_cast<FairMQMessageZMQ*>(msg)->fMessage));
+  if (rc != 0) {
+    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) {
+    stringstream logmsg;
+    logmsg << "failed closing message with data, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+}

fairmq/zeromq/FairMQMessageZMQ.h

@@ -0,0 +1,44 @@
+/**
+ * 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 SetMessage(void* data, size_t size);
+
+    virtual void Copy(FairMQMessage* msg);
+
+    static void CleanUp(void* data, void* hint);
+
+    virtual ~FairMQMessageZMQ();
+
+  private:
+    zmq_msg_t fMessage;
+};
+
+#endif /* FAIRMQMESSAGEZMQ_H_ */

fairmq/zeromq/FairMQPollerZMQ.cxx

@@ -0,0 +1,41 @@
+/**
+ * FairMQPollerZMQ.cxx
+ *
+ * @since 2014-01-23
+ * @author A. Rybalchenko
+ */
+
+#include <zmq.h>
+
+#include "FairMQPollerZMQ.h"
+
+FairMQPollerZMQ::FairMQPollerZMQ(const vector<FairMQSocket*>& inputs)
+{
+  fNumItems = inputs.size();
+  items = new zmq_pollitem_t[fNumItems];
+
+  for (int i = 0; i < fNumItems; i++) {
+    items[i].socket = inputs.at(i)->GetSocket();
+    items[i].fd = 0;
+    items[i].events = ZMQ_POLLIN;
+    items[i].revents = 0;
+  }
+}
+
+void FairMQPollerZMQ::Poll(int timeout)
+{
+  zmq_poll(items, fNumItems, timeout);
+}
+
+bool FairMQPollerZMQ::CheckInput(int index)
+{
+  if (items[index].revents & ZMQ_POLLIN) 
+    return true;
+
+  return false;
+}
+
+FairMQPollerZMQ::~FairMQPollerZMQ()
+{
+  if (items != NULL) delete [] items;
+}

fairmq/zeromq/FairMQPollerZMQ.h

@@ -0,0 +1,33 @@
+/**
+ * FairMQPollerZMQ.h
+ *
+ * @since 2014-01-23
+ * @author A. Rybalchenko
+ */
+
+#ifndef FAIRMQPOLLERZMQ_H_
+#define FAIRMQPOLLERZMQ_H_
+
+#include <vector>
+
+#include "FairMQPoller.h"
+#include "FairMQSocket.h"
+
+using std::vector;
+
+class FairMQPollerZMQ : public FairMQPoller
+{
+  public:
+    FairMQPollerZMQ(const vector<FairMQSocket*>& inputs);
+
+    virtual void Poll(int timeout);
+    virtual bool CheckInput(int index);
+
+    virtual ~FairMQPollerZMQ();
+
+  private:
+    zmq_pollitem_t* items;
+    int fNumItems;
+};
+
+#endif /* FAIRMQPOLLERZMQ_H_ */

fairmq/zeromq/FairMQSocketZMQ.cxx

@@ -0,0 +1,187 @@
+/**
+ * FairMQSocketZMQ.cxx
+ *
+ * @since 2012-12-05
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <sstream>
+
+#include "FairMQSocketZMQ.h"
+#include "FairMQLogger.h"
+
+boost::shared_ptr<FairMQContextZMQ> FairMQSocketZMQ::fContext = boost::shared_ptr<FairMQContextZMQ>(new FairMQContextZMQ(1)); // TODO: numIoThreads!
+
+FairMQSocketZMQ::FairMQSocketZMQ(const string& type, int num) :
+  fBytesTx(0),
+  fBytesRx(0),
+  fMessagesTx(0),
+  fMessagesRx(0)
+{
+  stringstream id; // TODO
+  id << type << "." << num;
+  fId = id.str();
+
+  fSocket = zmq_socket(fContext->GetContext(), GetConstant(type));
+  int rc = zmq_setsockopt(fSocket, ZMQ_IDENTITY, &fId, fId.length());
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed setting socket option, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+
+  if (type == "sub") {
+    rc = zmq_setsockopt(fSocket, ZMQ_SUBSCRIBE, NULL, 0);
+    if (rc != 0) {
+      stringstream logmsg2;
+      logmsg2 << "failed setting socket option, reason: " << zmq_strerror(errno);
+      FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
+    }
+  }
+
+  stringstream logmsg3;
+  logmsg3 << "created socket #" << fId;
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg3.str());
+}
+
+string FairMQSocketZMQ::GetId()
+{
+  return fId;
+}
+
+void FairMQSocketZMQ::Bind(const string& address)
+{
+  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) {
+    stringstream logmsg2;
+    logmsg2 << "failed binding socket #" << fId << ", reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg2.str());
+  }
+}
+
+void FairMQSocketZMQ::Connect(const string& address)
+{
+  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) {
+    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;
+  }
+  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;
+  }
+  stringstream logmsg;
+  logmsg << "failed receiving on socket #" << fId << ", reason: " << zmq_strerror(errno);
+  FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  return nbytes;
+}
+
+void FairMQSocketZMQ::Close()
+{
+  if (fSocket == NULL){
+    return;
+  }
+
+  int rc = zmq_close (fSocket);
+  if (rc != 0) {
+    stringstream logmsg;
+    logmsg << "failed closing socket, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+
+  fSocket = NULL;
+}
+
+void* FairMQSocketZMQ::GetSocket()
+{
+  return fSocket;
+}
+
+int FairMQSocketZMQ::GetSocket(int nothing)
+{
+  // dummy method to comply with the interface. functionality not possible in zeromq.
+  return -1;
+}
+
+void FairMQSocketZMQ::SetOption(const string& option, const void* value, size_t valueSize)
+{
+  int rc = zmq_setsockopt(fSocket, GetConstant(option), value, valueSize);
+  if (rc < 0) {
+    stringstream logmsg;
+    logmsg << "failed setting socket option, reason: " << zmq_strerror(errno);
+    FairMQLogger::GetInstance()->Log(FairMQLogger::ERROR, logmsg.str());
+  }
+}
+
+unsigned long FairMQSocketZMQ::GetBytesTx()
+{
+  return fBytesTx;
+}
+
+unsigned long FairMQSocketZMQ::GetBytesRx()
+{
+  return fBytesRx;
+}
+
+unsigned long FairMQSocketZMQ::GetMessagesTx()
+{
+  return fMessagesTx;
+}
+
+unsigned long FairMQSocketZMQ::GetMessagesRx()
+{
+  return fMessagesRx;
+}
+
+int FairMQSocketZMQ::GetConstant(const string& constant)
+{
+  if (constant == "sub") return ZMQ_SUB;
+  if (constant == "pub") return ZMQ_PUB;
+  if (constant == "xsub") return ZMQ_XSUB;
+  if (constant == "xpub") return ZMQ_XPUB;
+  if (constant == "push") return ZMQ_PUSH;
+  if (constant == "pull") return ZMQ_PULL;
+  if (constant == "snd-hwm") return ZMQ_SNDHWM;
+  if (constant == "rcv-hwm") return ZMQ_RCVHWM;
+
+  return -1;
+}
+
+FairMQSocketZMQ::~FairMQSocketZMQ()
+{
+}

fairmq/zeromq/FairMQSocketZMQ.h

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

fairmq/zeromq/FairMQTransportFactoryZMQ.cxx

@@ -0,0 +1,38 @@
+/**
+ * FairMQTransportFactoryZMQ.cxx
+ *
+ * @since 2014-01-20
+ * @author: A. Rybalchenko
+ */
+
+#include "FairMQTransportFactoryZMQ.h"
+
+FairMQTransportFactoryZMQ::FairMQTransportFactoryZMQ()
+{
+
+}
+
+FairMQMessage* FairMQTransportFactoryZMQ::CreateMessage()
+{
+  return new FairMQMessageZMQ();
+}
+
+FairMQMessage* FairMQTransportFactoryZMQ::CreateMessage(size_t size)
+{
+  return new FairMQMessageZMQ(size);
+}
+
+FairMQMessage* FairMQTransportFactoryZMQ::CreateMessage(void* data, size_t size)
+{
+  return new FairMQMessageZMQ(data, size);
+}
+
+FairMQSocket* FairMQTransportFactoryZMQ::CreateSocket(const string& type, int num)
+{
+  return new FairMQSocketZMQ(type, num);
+}
+
+FairMQPoller* FairMQTransportFactoryZMQ::CreatePoller(const vector<FairMQSocket*>& inputs)
+{
+  return new FairMQPollerZMQ(inputs);
+}

fairmq/zeromq/FairMQTransportFactoryZMQ.h

@@ -0,0 +1,34 @@
+/**
+ * FairMQTransportFactoryZMQ.h
+ *
+ * @since 2014-01-20
+ * @author: A. Rybalchenko
+ */
+
+#ifndef FAIRMQTRANSPORTFACTORYZMQ_H_
+#define FAIRMQTRANSPORTFACTORYZMQ_H_
+
+#include <vector>
+
+#include "FairMQTransportFactory.h"
+#include "FairMQContextZMQ.h"
+#include "FairMQMessageZMQ.h"
+#include "FairMQSocketZMQ.h"
+#include "FairMQPollerZMQ.h"
+
+class FairMQTransportFactoryZMQ : public FairMQTransportFactory
+{
+  public:
+    FairMQTransportFactoryZMQ();
+
+    virtual FairMQMessage* CreateMessage();
+    virtual FairMQMessage* CreateMessage(size_t size);
+    virtual FairMQMessage* CreateMessage(void* data, size_t size);
+    virtual FairMQSocket* CreateSocket(const string& type, int num);
+    virtual FairMQPoller* CreatePoller(const vector<FairMQSocket*>& inputs);
+
+
+    virtual ~FairMQTransportFactoryZMQ() {};
+};
+
+#endif /* FAIRMQTRANSPORTFACTORYZMQ_H_ */

fairmq/zeromq/runBenchmarkSampler.cxx

@@ -0,0 +1,115 @@
+/**
+ * runBenchmarkSampler.cxx
+ *
+ * @since 2013-04-23
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQBenchmarkSampler.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQBenchmarkSampler sampler;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  sampler.ChangeState(FairMQBenchmarkSampler::STOP);
+  sampler.ChangeState(FairMQBenchmarkSampler::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc != 9 ) {
+    cout << "Usage: bsampler ID eventSize eventRate numIoTreads\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n"
+              << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  sampler.SetTransport(transportFactory);
+
+  int i = 1;
+
+  sampler.SetProperty(FairMQBenchmarkSampler::Id, argv[i]);
+  ++i;
+
+  int eventSize;
+  stringstream(argv[i]) >> eventSize;
+  sampler.SetProperty(FairMQBenchmarkSampler::EventSize, eventSize);
+  ++i;
+
+  int eventRate;
+  stringstream(argv[i]) >> eventRate;
+  sampler.SetProperty(FairMQBenchmarkSampler::EventRate, eventRate);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  sampler.SetProperty(FairMQBenchmarkSampler::NumIoThreads, numIoThreads);
+  ++i;
+
+  sampler.SetProperty(FairMQBenchmarkSampler::NumInputs, 0);
+  sampler.SetProperty(FairMQBenchmarkSampler::NumOutputs, 1);
+
+
+  sampler.ChangeState(FairMQBenchmarkSampler::INIT);
+
+
+  sampler.SetProperty(FairMQBenchmarkSampler::OutputSocketType, argv[i], 0);
+  ++i;
+  int outputSndBufSize;
+  stringstream(argv[i]) >> outputSndBufSize;
+  sampler.SetProperty(FairMQBenchmarkSampler::OutputSndBufSize, outputSndBufSize, 0);
+  ++i;
+  sampler.SetProperty(FairMQBenchmarkSampler::OutputMethod, argv[i], 0);
+  ++i;
+  sampler.SetProperty(FairMQBenchmarkSampler::OutputAddress, argv[i], 0);
+  ++i;
+
+
+  sampler.ChangeState(FairMQBenchmarkSampler::SETOUTPUT);
+  sampler.ChangeState(FairMQBenchmarkSampler::SETINPUT);
+  sampler.ChangeState(FairMQBenchmarkSampler::RUN);
+
+
+
+  char ch;
+  cin.get(ch);
+
+  sampler.ChangeState(FairMQBenchmarkSampler::STOP);
+  sampler.ChangeState(FairMQBenchmarkSampler::END);
+
+  return 0;
+}
+

fairmq/zeromq/runBuffer.cxx

@@ -0,0 +1,115 @@
+/**
+ * runBuffer.cxx
+ *
+ * @since 2012-10-26
+ * @author: D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQBuffer.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQBuffer buffer;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  buffer.ChangeState(FairMQBuffer::STOP);
+  buffer.ChangeState(FairMQBuffer::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc != 11 ) {
+    cout << "Usage: buffer \tID numIoTreads\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n" << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  buffer.SetTransport(transportFactory);
+
+  int i = 1;
+
+  buffer.SetProperty(FairMQBuffer::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  buffer.SetProperty(FairMQBuffer::NumIoThreads, numIoThreads);
+  ++i;
+  buffer.SetProperty(FairMQBuffer::NumInputs, 1);
+  buffer.SetProperty(FairMQBuffer::NumOutputs, 1);
+
+
+  buffer.ChangeState(FairMQBuffer::INIT);
+
+
+  buffer.SetProperty(FairMQBuffer::InputSocketType, argv[i], 0);
+  ++i;
+  int inputRcvBufSize;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  buffer.SetProperty(FairMQBuffer::InputRcvBufSize, inputRcvBufSize, 0);
+  ++i;
+  buffer.SetProperty(FairMQBuffer::InputMethod, argv[i], 0);
+  ++i;
+  buffer.SetProperty(FairMQBuffer::InputAddress, argv[i], 0);
+  ++i;
+
+  buffer.SetProperty(FairMQBuffer::OutputSocketType, argv[i], 0);
+  ++i;
+  int outputSndBufSize;
+  stringstream(argv[i]) >> outputSndBufSize;
+  buffer.SetProperty(FairMQBuffer::OutputSndBufSize, outputSndBufSize, 0);
+  ++i;
+  buffer.SetProperty(FairMQBuffer::OutputMethod, argv[i], 0);
+  ++i;
+  buffer.SetProperty(FairMQBuffer::OutputAddress, argv[i], 0);
+  ++i;
+
+
+  buffer.ChangeState(FairMQBuffer::SETOUTPUT);
+  buffer.ChangeState(FairMQBuffer::SETINPUT);
+  buffer.ChangeState(FairMQBuffer::RUN);
+
+
+
+  char ch;
+  cin.get(ch);
+
+  buffer.ChangeState(FairMQBuffer::STOP);
+  buffer.ChangeState(FairMQBuffer::END);
+
+  return 0;
+}
+

fairmq/zeromq/runMerger.cxx

@@ -0,0 +1,126 @@
+/**
+ * runMerger.cxx
+ *
+ * @since 2012-12-06
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQMerger.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQMerger merger;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  merger.ChangeState(FairMQMerger::STOP);
+  merger.ChangeState(FairMQMerger::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc != 15 ) {
+    cout << "Usage: merger \tID numIoTreads\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n" << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  merger.SetTransport(transportFactory);
+
+  int i = 1;
+
+  merger.SetProperty(FairMQMerger::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  merger.SetProperty(FairMQMerger::NumIoThreads, numIoThreads);
+  ++i;
+
+  merger.SetProperty(FairMQMerger::NumInputs, 2);
+  merger.SetProperty(FairMQMerger::NumOutputs, 1);
+
+
+  merger.ChangeState(FairMQMerger::INIT);
+
+
+  merger.SetProperty(FairMQMerger::InputSocketType, argv[i], 0);
+  ++i;
+  int inputRcvBufSize;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  merger.SetProperty(FairMQMerger::InputRcvBufSize, inputRcvBufSize, 0);
+  ++i;
+  merger.SetProperty(FairMQMerger::InputMethod, argv[i], 0);
+  ++i;
+  merger.SetProperty(FairMQMerger::InputAddress, argv[i], 0);
+  ++i;
+
+  merger.SetProperty(FairMQMerger::InputSocketType, argv[i], 1);
+  ++i;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  merger.SetProperty(FairMQMerger::InputRcvBufSize, inputRcvBufSize, 1);
+  ++i;
+  merger.SetProperty(FairMQMerger::InputMethod, argv[i], 1);
+  ++i;
+  merger.SetProperty(FairMQMerger::InputAddress, argv[i], 1);
+  ++i;
+
+  merger.SetProperty(FairMQMerger::OutputSocketType, argv[i], 0);
+  ++i;
+  int outputSndBufSize;
+  stringstream(argv[i]) >> outputSndBufSize;
+  merger.SetProperty(FairMQMerger::OutputSndBufSize, outputSndBufSize, 0);
+  ++i;
+  merger.SetProperty(FairMQMerger::OutputMethod, argv[i], 0);
+  ++i;
+  merger.SetProperty(FairMQMerger::OutputAddress, argv[i], 0);
+  ++i;
+
+
+  merger.ChangeState(FairMQMerger::SETOUTPUT);
+  merger.ChangeState(FairMQMerger::SETINPUT);
+  merger.ChangeState(FairMQMerger::RUN);
+
+
+  char ch;
+  cin.get(ch);
+
+  merger.ChangeState(FairMQMerger::STOP);
+  merger.ChangeState(FairMQMerger::END);
+
+  return 0;
+}
+

fairmq/zeromq/runNToOneMerger.cxx

@@ -0,0 +1,124 @@
+/**
+ * runNToOneMerger.cxx
+ *
+ * @since 2012-12-06
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQMerger.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQMerger merger;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  merger.ChangeState(FairMQMerger::STOP);
+  merger.ChangeState(FairMQMerger::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc < 16 || (argc-8)%4!=0 ) {
+    cout << "Usage: merger \tID numIoTreads numInputs\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\t...\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n"
+              << argc << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  merger.SetTransport(transportFactory);
+
+  int i = 1;
+
+  merger.SetProperty(FairMQMerger::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  merger.SetProperty(FairMQMerger::NumIoThreads, numIoThreads);
+  ++i;
+
+  int numInputs;
+  stringstream(argv[i]) >> numInputs;
+  merger.SetProperty(FairMQMerger::NumInputs, numInputs);
+  ++i;
+
+  merger.SetProperty(FairMQMerger::NumOutputs, 1);
+
+
+  merger.ChangeState(FairMQMerger::INIT);
+
+
+  for (int iInput = 0; iInput < numInputs; iInput++ ) {
+    merger.SetProperty(FairMQMerger::InputSocketType, argv[i], iInput);
+    ++i;
+    int inputRcvBufSize;
+    stringstream(argv[i]) >> inputRcvBufSize;
+    merger.SetProperty(FairMQMerger::InputRcvBufSize, inputRcvBufSize, iInput);
+    ++i;
+    merger.SetProperty(FairMQMerger::InputMethod, argv[i], iInput);
+    ++i;
+    merger.SetProperty(FairMQMerger::InputAddress, argv[i], iInput);
+    ++i;
+  }
+
+  merger.SetProperty(FairMQMerger::OutputSocketType, argv[i], 0);
+  ++i;
+  int outputSndBufSize;
+  stringstream(argv[i]) >> outputSndBufSize;
+  merger.SetProperty(FairMQMerger::OutputSndBufSize, outputSndBufSize, 0);
+  ++i;
+  merger.SetProperty(FairMQMerger::OutputMethod, argv[i], 0);
+  ++i;
+  merger.SetProperty(FairMQMerger::OutputAddress, argv[i], 0);
+  ++i;
+
+
+  merger.ChangeState(FairMQMerger::SETOUTPUT);
+  merger.ChangeState(FairMQMerger::SETINPUT);
+  merger.ChangeState(FairMQMerger::RUN);
+
+
+  char ch;
+  cin.get(ch);
+
+  merger.ChangeState(FairMQMerger::STOP);
+  merger.ChangeState(FairMQMerger::END);
+
+  return 0;
+}
+

fairmq/zeromq/runOneToNSplitter.cxx

@@ -0,0 +1,122 @@
+/**
+ * runOneToNSplitter.cxx
+ *
+ * @since 2012-12-06
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQSplitter.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQSplitter splitter;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  splitter.ChangeState(FairMQSplitter::STOP);
+  splitter.ChangeState(FairMQSplitter::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc < 16 || (argc - 8) % 4 != 0 ) { // argc{ name, id, threads, nout, insock, inbuff, inmet, inadd, ... out}
+    cout << "Usage: splitter \tID numIoTreads numOutputs\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n"
+              << "\t\t..." << argc << " arguments provided" << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  splitter.SetTransport(transportFactory);
+
+  int i = 1;
+
+  splitter.SetProperty(FairMQSplitter::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  splitter.SetProperty(FairMQSplitter::NumIoThreads, numIoThreads);
+  ++i;
+
+  splitter.SetProperty(FairMQSplitter::NumInputs, 1);
+
+  int numOutputs;
+  stringstream(argv[i]) >> numOutputs;
+  splitter.SetProperty(FairMQSplitter::NumOutputs, numOutputs);
+  ++i;
+
+
+  splitter.ChangeState(FairMQSplitter::INIT);
+
+
+  splitter.SetProperty(FairMQSplitter::InputSocketType, argv[i], 0);
+  ++i;
+  int inputRcvBufSize;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  splitter.SetProperty(FairMQSplitter::InputRcvBufSize, inputRcvBufSize, 0);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::InputMethod, argv[i], 0);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::InputAddress, argv[i], 0);
+  ++i;
+
+  int outputSndBufSize;
+  for (int iOutput = 0; iOutput < numOutputs; iOutput++) {
+    splitter.SetProperty(FairMQSplitter::OutputSocketType, argv[i], iOutput);
+    ++i;
+    stringstream(argv[i]) >> outputSndBufSize;
+    splitter.SetProperty(FairMQSplitter::OutputSndBufSize, outputSndBufSize, iOutput);
+    ++i;
+    splitter.SetProperty(FairMQSplitter::OutputMethod, argv[i], iOutput);
+    ++i;
+    splitter.SetProperty(FairMQSplitter::OutputAddress, argv[i], iOutput);
+    ++i;
+  }
+
+  splitter.ChangeState(FairMQSplitter::SETOUTPUT);
+  splitter.ChangeState(FairMQSplitter::SETINPUT);
+  splitter.ChangeState(FairMQSplitter::RUN);
+
+
+  char ch;
+  cin.get(ch);
+
+  splitter.ChangeState(FairMQSplitter::STOP);
+  splitter.ChangeState(FairMQSplitter::END);
+
+  return 0;
+}
+

fairmq/zeromq/runProxy.cxx

@@ -0,0 +1,115 @@
+/**
+ * runProxy.cxx
+ *
+ * @since 2013-10-07
+ * @author A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQProxy.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQProxy proxy;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  proxy.ChangeState(FairMQProxy::STOP);
+  proxy.ChangeState(FairMQProxy::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc != 11 ) {
+    cout << "Usage: proxy \tID numIoTreads\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n" << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  proxy.SetTransport(transportFactory);
+
+  int i = 1;
+
+  proxy.SetProperty(FairMQProxy::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  proxy.SetProperty(FairMQProxy::NumIoThreads, numIoThreads);
+  ++i;
+
+  proxy.SetProperty(FairMQProxy::NumInputs, 1);
+  proxy.SetProperty(FairMQProxy::NumOutputs, 1);
+
+
+  proxy.ChangeState(FairMQProxy::INIT);
+
+
+  proxy.SetProperty(FairMQProxy::InputSocketType, argv[i], 0);
+  ++i;
+  int inputRcvBufSize;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  proxy.SetProperty(FairMQProxy::InputRcvBufSize, inputRcvBufSize, 0);
+  ++i;
+  proxy.SetProperty(FairMQProxy::InputMethod, argv[i], 0);
+  ++i;
+  proxy.SetProperty(FairMQProxy::InputAddress, argv[i], 0);
+  ++i;
+
+  proxy.SetProperty(FairMQProxy::OutputSocketType, argv[i], 0);
+  ++i;
+  int outputSndBufSize;
+  stringstream(argv[i]) >> outputSndBufSize;
+  proxy.SetProperty(FairMQProxy::OutputSndBufSize, outputSndBufSize, 0);
+  ++i;
+  proxy.SetProperty(FairMQProxy::OutputMethod, argv[i], 0);
+  ++i;
+  proxy.SetProperty(FairMQProxy::OutputAddress, argv[i], 0);
+  ++i;
+
+
+  proxy.ChangeState(FairMQProxy::SETOUTPUT);
+  proxy.ChangeState(FairMQProxy::SETINPUT);
+  proxy.ChangeState(FairMQProxy::RUN);
+
+
+  char ch;
+  cin.get(ch);
+
+  proxy.ChangeState(FairMQProxy::STOP);
+  proxy.ChangeState(FairMQProxy::END);
+
+  return 0;
+}
+

fairmq/zeromq/runSink.cxx

@@ -0,0 +1,104 @@
+/**
+ * runSink.cxx
+ *
+ * @since 2013-01-21
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQSink.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQSink sink;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  sink.ChangeState(FairMQSink::STOP);
+  sink.ChangeState(FairMQSink::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc != 7 ) {
+    cout << "Usage: sink \tID numIoTreads\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  sink.SetTransport(transportFactory);
+
+  int i = 1;
+
+  sink.SetProperty(FairMQSink::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  sink.SetProperty(FairMQSink::NumIoThreads, numIoThreads);
+  ++i;
+
+  sink.SetProperty(FairMQSink::NumInputs, 1);
+  sink.SetProperty(FairMQSink::NumOutputs, 0);
+
+
+  sink.ChangeState(FairMQSink::INIT);
+
+
+  sink.SetProperty(FairMQSink::InputSocketType, argv[i], 0);
+  ++i;
+  int inputRcvBufSize;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  sink.SetProperty(FairMQSink::InputRcvBufSize, inputRcvBufSize, 0);
+  ++i;
+  sink.SetProperty(FairMQSink::InputMethod, argv[i], 0);
+  ++i;
+  sink.SetProperty(FairMQSink::InputAddress, argv[i], 0);
+  ++i;
+
+
+  sink.ChangeState(FairMQSink::SETOUTPUT);
+  sink.ChangeState(FairMQSink::SETINPUT);
+  sink.ChangeState(FairMQSink::RUN);
+
+
+  char ch;
+  cin.get(ch);
+
+  sink.ChangeState(FairMQSink::STOP);
+  sink.ChangeState(FairMQSink::END);
+
+  return 0;
+}
+

fairmq/zeromq/runSplitter.cxx

@@ -0,0 +1,126 @@
+/**
+ * runSplitter.cxx
+ *
+ * @since 2012-12-06
+ * @author D. Klein, A. Rybalchenko
+ */
+
+#include <iostream>
+#include <csignal>
+
+#include "FairMQLogger.h"
+#include "FairMQSplitter.h"
+#include "FairMQTransportFactoryZMQ.h"
+
+using std::cout;
+using std::cin;
+using std::endl;
+using std::stringstream;
+
+
+FairMQSplitter splitter;
+
+static void s_signal_handler (int signal)
+{
+  cout << endl << "Caught signal " << signal << endl;
+
+  splitter.ChangeState(FairMQSplitter::STOP);
+  splitter.ChangeState(FairMQSplitter::END);
+
+  cout << "Shutdown complete. Bye!" << endl;
+  exit(1);
+}
+
+static void s_catch_signals (void)
+{
+  struct sigaction action;
+  action.sa_handler = s_signal_handler;
+  action.sa_flags = 0;
+  sigemptyset(&action.sa_mask);
+  sigaction(SIGINT, &action, NULL);
+  sigaction(SIGTERM, &action, NULL);
+}
+
+int main(int argc, char** argv)
+{
+  if ( argc != 15 ) {
+    cout << "Usage: splitter \tID numIoTreads\n"
+              << "\t\tinputSocketType inputRcvBufSize inputMethod inputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n"
+              << "\t\toutputSocketType outputSndBufSize outputMethod outputAddress\n" << endl;
+    return 1;
+  }
+
+  s_catch_signals();
+
+  stringstream logmsg;
+  logmsg << "PID: " << getpid();
+  FairMQLogger::GetInstance()->Log(FairMQLogger::INFO, logmsg.str());
+
+  FairMQTransportFactory* transportFactory = new FairMQTransportFactoryZMQ();
+  splitter.SetTransport(transportFactory);
+
+  int i = 1;
+
+  splitter.SetProperty(FairMQSplitter::Id, argv[i]);
+  ++i;
+
+  int numIoThreads;
+  stringstream(argv[i]) >> numIoThreads;
+  splitter.SetProperty(FairMQSplitter::NumIoThreads, numIoThreads);
+  ++i;
+
+  splitter.SetProperty(FairMQSplitter::NumInputs, 1);
+  splitter.SetProperty(FairMQSplitter::NumOutputs, 2);
+
+
+  splitter.ChangeState(FairMQSplitter::INIT);
+
+
+  splitter.SetProperty(FairMQSplitter::InputSocketType, argv[i], 0);
+  ++i;
+  int inputRcvBufSize;
+  stringstream(argv[i]) >> inputRcvBufSize;
+  splitter.SetProperty(FairMQSplitter::InputRcvBufSize, inputRcvBufSize, 0);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::InputMethod, argv[i], 0);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::InputAddress, argv[i], 0);
+  ++i;
+
+  splitter.SetProperty(FairMQSplitter::OutputSocketType, argv[i], 0);
+  ++i;
+  int outputSndBufSize;
+  stringstream(argv[i]) >> outputSndBufSize;
+  splitter.SetProperty(FairMQSplitter::OutputSndBufSize, outputSndBufSize, 0);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::OutputMethod, argv[i], 0);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::OutputAddress, argv[i], 0);
+  ++i;
+
+  splitter.SetProperty(FairMQSplitter::OutputSocketType, argv[i], 1);
+  ++i;
+  stringstream(argv[i]) >> outputSndBufSize;
+  splitter.SetProperty(FairMQSplitter::OutputSndBufSize, outputSndBufSize, 1);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::OutputMethod, argv[i], 1);
+  ++i;
+  splitter.SetProperty(FairMQSplitter::OutputAddress, argv[i], 1);
+  ++i;
+
+
+  splitter.ChangeState(FairMQSplitter::SETOUTPUT);
+  splitter.ChangeState(FairMQSplitter::SETINPUT);
+  splitter.ChangeState(FairMQSplitter::RUN);
+
+
+  char ch;
+  cin.get(ch);
+
+  splitter.ChangeState(FairMQSplitter::STOP);
+  splitter.ChangeState(FairMQSplitter::END);
+
+  return 0;
+}
+