Allow plugins to create channels

This also fixes a bug, that prevented the usage of custom types with the
plugin config API.

CMakeLists.txt

@@ -49,7 +49,7 @@ find_package(Threads REQUIRED)
 
 if(BUILD_FAIRMQ)
   find_package2(PUBLIC Boost VERSION 1.64 REQUIRED
-    COMPONENTS program_options thread system filesystem regex date_time signals
+    COMPONENTS container program_options thread system filesystem regex date_time signals
   )
   find_package2(PUBLIC FairLogger VERSION 1.2.0 REQUIRED)
   find_package2(PRIVATE ZeroMQ VERSION 4.1.5 REQUIRED)

examples/CMakeLists.txt

@@ -8,6 +8,7 @@
 
 add_subdirectory(1-1)
 add_subdirectory(1-n-1)
+add_subdirectory(builtin-devices)
 add_subdirectory(copypush)
 add_subdirectory(dds)
 add_subdirectory(multipart)

examples/builtin-devices/CMakeLists.txt

@@ -0,0 +1,50 @@
+ ################################################################################
+ #    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    #
+ #                                                                              #
+ #              This software is distributed under the terms of the             #
+ #              GNU Lesser General Public Licence (LGPL) version 3,             #
+ #                  copied verbatim in the file "LICENSE"                       #
+ ################################################################################
+
+set(EX_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR})
+set(FAIRMQ_BIN_DIR ${CMAKE_BINARY_DIR}/fairmq)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-builtin-devices.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-builtin-devices.sh)
+
+# test
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-builtin-devices.sh.in ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh)
+
+add_test(NAME Example-Builtin-Devices-zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh zeromq)
+set_tests_properties(Example-Builtin-Devices-zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
+
+if(BUILD_NANOMSG_TRANSPORT)
+  add_test(NAME Example-Builtin-Devices-nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh nanomsg)
+  set_tests_properties(Example-Builtin-Devices-nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
+endif()
+
+add_test(NAME Example-Builtin-Devices-shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh shmem)
+set_tests_properties(Example-Builtin-Devices-shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
+
+add_test(NAME Example-Builtin-Devices-zeromq-multipart COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh zeromq true 2)
+set_tests_properties(Example-Builtin-Devices-zeromq-multipart PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
+
+if(BUILD_NANOMSG_TRANSPORT)
+  add_test(NAME Example-Builtin-Devices-nanomsg-multipart COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh nanomsg true 2)
+  set_tests_properties(Example-Builtin-Devices-nanomsg-multipart PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
+endif()
+
+add_test(NAME Example-Builtin-Devices-shmem-multipart COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh shmem true 2)
+set_tests_properties(Example-Builtin-Devices-shmem-multipart PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
+
+# install
+
+# configure run script with different executable paths for build and for install directories
+set(EX_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR})
+set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-builtin-devices.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-builtin-devices.sh_install)
+
+install(
+    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-builtin-devices.sh_install
+    DESTINATION ${PROJECT_INSTALL_BINDIR}
+    RENAME fairmq-start-ex-builtin-devices.sh
+)

examples/builtin-devices/README.md

@@ -0,0 +1,4 @@
+Built-in devices
+==========================
+
+This example demonstrates use of generic devices that are provided with FairMQ - BenchmarkSampler, Merger, Multiplier, Proxy, Sink, Splitter. They are all connected in one topology and transfer some dummy buffers generated by the BenchmarkSampler.

examples/builtin-devices/fairmq-start-ex-builtin-devices.sh.in

@@ -0,0 +1,93 @@
+#!/bin/bash
+
+export FAIRMQ_PATH=@FAIRMQ_BIN_DIR@
+
+transport="zeromq"
+multipart="false"
+numParts="1"
+
+if [[ $1 =~ ^[a-z]+$ ]]; then
+    transport=$1
+fi
+
+if [[ $2 =~ ^[a-z]+$ ]]; then
+    multipart=$2
+fi
+
+if [[ $3 =~ ^[0-9]+$ ]]; then
+    numParts=$3
+fi
+
+SAMPLER="fairmq-bsampler"
+SAMPLER+=" --id bsampler1"
+SAMPLER+=" --transport $transport"
+SAMPLER+=" --control interactive"
+SAMPLER+=" --severity debug"
+SAMPLER+=" --msg-size 100000"
+SAMPLER+=" --multipart $multipart"
+SAMPLER+=" --num-parts $numParts"
+SAMPLER+=" --msg-rate 100"
+SAMPLER+=" --max-iterations 0"
+SAMPLER+=" --out-channel data1"
+SAMPLER+=" --channel-config name=data1,type=push,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5555"
+xterm -geometry 90x20+0+175 -hold -e @FAIRMQ_BIN_DIR@/$SAMPLER &
+
+SPLITTER="fairmq-splitter"
+SPLITTER+=" --id splitter"
+SPLITTER+=" --transport $transport"
+SPLITTER+=" --multipart $multipart"
+SPLITTER+=" --in-channel data1"
+SPLITTER+=" --out-channel data2"
+SPLITTER+=" --channel-config name=data1,type=pull,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5555"
+SPLITTER+="                  name=data2,type=push,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5556,address=tcp://localhost:5557"
+xterm -geometry 90x20+0+475 -hold -e @FAIRMQ_BIN_DIR@/$SPLITTER &
+
+PROXY1="fairmq-proxy"
+PROXY1+=" --id proxy1"
+PROXY1+=" --transport $transport"
+PROXY1+=" --multipart $multipart"
+PROXY1+=" --in-channel data2"
+PROXY1+=" --out-channel data3"
+PROXY1+=" --channel-config name=data2,type=pull,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5556"
+PROXY1+="                  name=data3,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5558"
+xterm -geometry 90x20+550+175 -hold -e @FAIRMQ_BIN_DIR@/$PROXY1 &
+
+PROXY2="fairmq-proxy"
+PROXY2+=" --id proxy2"
+PROXY2+=" --transport $transport"
+PROXY2+=" --multipart $multipart"
+PROXY2+=" --in-channel data2"
+PROXY2+=" --out-channel data3"
+PROXY2+=" --channel-config name=data2,type=pull,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5557"
+PROXY2+="                  name=data3,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5559"
+xterm -geometry 90x20+550+475 -hold -e @FAIRMQ_BIN_DIR@/$PROXY2 &
+
+MERGER="fairmq-merger"
+MERGER+=" --id merger"
+MERGER+=" --transport $transport"
+MERGER+=" --multipart $multipart"
+MERGER+=" --in-channel data3"
+MERGER+=" --out-channel data4"
+MERGER+=" --channel-config name=data3,type=pull,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5558,address=tcp://localhost:5559"
+MERGER+="                  name=data4,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5560"
+xterm -geometry 90x20+1100+50 -hold -e @FAIRMQ_BIN_DIR@/$MERGER &
+
+MULTIPLIER="fairmq-multiplier"
+MULTIPLIER+=" --id multiplier"
+MULTIPLIER+=" --transport $transport"
+MULTIPLIER+=" --multipart $multipart"
+MULTIPLIER+=" --in-channel data4"
+MULTIPLIER+=" --out-channel data5"
+MULTIPLIER+=" --channel-config name=data4,type=pull,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5560"
+MULTIPLIER+="                  name=data5,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5561,address=tcp://localhost:5561"
+xterm -geometry 90x20+1100+350 -hold -e @FAIRMQ_BIN_DIR@/$MULTIPLIER &
+
+SINK="fairmq-sink"
+SINK+=" --id sink1"
+SINK+=" --transport $transport"
+SINK+=" --severity debug"
+SINK+=" --multipart $multipart"
+SINK+=" --max-iterations 0"
+SINK+=" --in-channel data5"
+SINK+=" --channel-config name=data5,type=pull,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5561"
+xterm -geometry 90x20+1100+650 -hold -e @FAIRMQ_BIN_DIR@/$SINK &

examples/builtin-devices/test-ex-builtin-devices.sh.in

@@ -0,0 +1,148 @@
+#!/bin/bash
+
+export FAIRMQ_PATH=@FAIRMQ_BIN_DIR@
+
+SESSION="$(@CMAKE_BINARY_DIR@/fairmq/fairmq-uuid-gen -h)"
+
+transport="zeromq"
+multipart="false"
+numParts="1"
+
+if [[ $1 =~ ^[a-z]+$ ]]; then
+    transport=$1
+fi
+
+if [[ $2 =~ ^[a-z]+$ ]]; then
+    multipart=$2
+fi
+
+if [[ $3 =~ ^[0-9]+$ ]]; then
+    numParts=$3
+fi
+
+# setup a trap to kill everything if the test fails/timeouts
+trap 'kill -TERM $SAMPLER_PID; kill -TERM $SPLITTER_PID; kill -TERM $PROXY1_PID; kill -TERM $PROXY2_PID; kill -TERM $MERGER_PID; kill -TERM $MULTIPLIER_PID; kill -TERM $SINK_PID;' TERM
+
+SAMPLER="fairmq-bsampler"
+SAMPLER+=" --id bsampler1"
+SAMPLER+=" --session $SESSION"
+SAMPLER+=" --transport $transport"
+SAMPLER+=" --color false"
+SAMPLER+=" --control static"
+SAMPLER+=" --verbosity veryhigh"
+SAMPLER+=" --severity debug"
+SAMPLER+=" --msg-size 100000"
+SAMPLER+=" --multipart $multipart"
+SAMPLER+=" --num-parts $numParts"
+SAMPLER+=" --msg-rate 1"
+SAMPLER+=" --max-iterations 0"
+SAMPLER+=" --out-channel data1"
+SAMPLER+=" --channel-config name=data1,type=push,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5555"
+@FAIRMQ_BIN_DIR@/$SAMPLER &
+SAMPLER_PID=$!
+
+SPLITTER="fairmq-splitter"
+SPLITTER+=" --id splitter"
+SPLITTER+=" --session $SESSION"
+SPLITTER+=" --transport $transport"
+SPLITTER+=" --color false"
+SPLITTER+=" --control static"
+SPLITTER+=" --verbosity veryhigh"
+SPLITTER+=" --multipart $multipart"
+SPLITTER+=" --in-channel data1"
+SPLITTER+=" --out-channel data2"
+SPLITTER+=" --channel-config name=data1,type=pull,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5555"
+SPLITTER+="                  name=data2,type=push,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5556,address=tcp://localhost:5557"
+@FAIRMQ_BIN_DIR@/$SPLITTER &
+SPLITTER_PID=$!
+
+PROXY1="fairmq-proxy"
+PROXY1+=" --id proxy1"
+PROXY1+=" --session $SESSION"
+PROXY1+=" --transport $transport"
+PROXY1+=" --color false"
+PROXY1+=" --control static"
+PROXY1+=" --verbosity veryhigh"
+PROXY1+=" --multipart $multipart"
+PROXY1+=" --in-channel data2"
+PROXY1+=" --out-channel data3"
+PROXY1+=" --channel-config name=data2,type=pull,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5556"
+PROXY1+="                  name=data3,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5558"
+@FAIRMQ_BIN_DIR@/$PROXY1 &
+PROXY1_PID=$!
+
+PROXY2="fairmq-proxy"
+PROXY2+=" --id proxy2"
+PROXY2+=" --session $SESSION"
+PROXY2+=" --transport $transport"
+PROXY2+=" --color false"
+PROXY2+=" --control static"
+PROXY2+=" --verbosity veryhigh"
+PROXY2+=" --multipart $multipart"
+PROXY2+=" --in-channel data2"
+PROXY2+=" --out-channel data3"
+PROXY2+=" --channel-config name=data2,type=pull,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5557"
+PROXY2+="                  name=data3,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5559"
+@FAIRMQ_BIN_DIR@/$PROXY2 &
+PROXY2_PID=$!
+
+MERGER="fairmq-merger"
+MERGER+=" --id merger"
+MERGER+=" --session $SESSION"
+MERGER+=" --transport $transport"
+MERGER+=" --color false"
+MERGER+=" --control static"
+MERGER+=" --verbosity veryhigh"
+MERGER+=" --multipart $multipart"
+MERGER+=" --in-channel data3"
+MERGER+=" --out-channel data4"
+MERGER+=" --channel-config name=data3,type=pull,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5558,address=tcp://localhost:5559"
+MERGER+="                  name=data4,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5560"
+@FAIRMQ_BIN_DIR@/$MERGER &
+MERGER_PID=$!
+
+MULTIPLIER="fairmq-multiplier"
+MULTIPLIER+=" --id multiplier"
+MULTIPLIER+=" --session $SESSION"
+MULTIPLIER+=" --transport $transport"
+MULTIPLIER+=" --color false"
+MULTIPLIER+=" --control static"
+MULTIPLIER+=" --verbosity veryhigh"
+MULTIPLIER+=" --multipart $multipart"
+MULTIPLIER+=" --in-channel data4"
+MULTIPLIER+=" --out-channel data5"
+MULTIPLIER+=" --channel-config name=data4,type=pull,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5560"
+MULTIPLIER+="                  name=data5,type=push,method=connect,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5561,address=tcp://localhost:5561"
+@FAIRMQ_BIN_DIR@/$MULTIPLIER &
+MULTIPLIER_PID=$!
+
+SINK="fairmq-sink"
+SINK+=" --id sink1"
+SINK+=" --session $SESSION"
+SINK+=" --transport $transport"
+SINK+=" --color false"
+SINK+=" --control static"
+SINK+=" --verbosity veryhigh"
+SINK+=" --severity debug"
+SINK+=" --multipart $multipart"
+SINK+=" --max-iterations 2"
+SINK+=" --in-channel data5"
+SINK+=" --channel-config name=data5,type=pull,method=bind,sndBufSize=50,rcvBufSize=50,address=tcp://localhost:5561"
+@FAIRMQ_BIN_DIR@/$SINK &
+SINK_PID=$!
+
+wait $SINK_PID
+
+kill -SIGINT $SAMPLER_PID
+kill -SIGINT $SPLITTER_PID
+kill -SIGINT $PROXY1_PID
+kill -SIGINT $PROXY2_PID
+kill -SIGINT $MERGER_PID
+kill -SIGINT $MULTIPLIER_PID
+
+wait $SAMPLER_PID
+wait $SPLITTER_PID
+wait $PROXY1_PID
+wait $PROXY2_PID
+wait $MERGER_PID
+wait $MULTIPLIER_PID

examples/region/fairmq-start-ex-region.sh.in

@@ -14,12 +14,12 @@ SAMPLER+=" --severity debug"
 SAMPLER+=" --msg-size $msgSize"
 # SAMPLER+=" --rate 10"
 SAMPLER+=" --transport shmem"
-SAMPLER+=" --channel-config name=data,type=push,method=bind,address=tcp://127.0.0.1:7777"
+SAMPLER+=" --channel-config name=data,type=push,method=bind,address=tcp://127.0.0.1:7777,sndKernelSize=212992"
 xterm -geometry 80x23+0+0 -hold -e @EX_BIN_DIR@/$SAMPLER &
 
 SINK="fairmq-ex-region-sink"
 SINK+=" --id sink1"
 SINK+=" --severity debug"
 SINK+=" --transport shmem"
-SINK+=" --channel-config name=data,type=pull,method=connect,address=tcp://127.0.0.1:7777"
+SINK+=" --channel-config name=data,type=pull,method=connect,address=tcp://127.0.0.1:7777,rcvKernelSize=212992"
 xterm -geometry 80x23+500+0 -hold -e @EX_BIN_DIR@/$SINK &

fairmq/CMakeLists.txt

@@ -49,6 +49,8 @@ set(FAIRMQ_PUBLIC_HEADER_FILES
   FairMQSocket.h
   FairMQStateMachine.h
   FairMQTransportFactory.h
+  MemoryResources.h
+  MemoryResourceTools.h
   Tools.h
   Transports.h
   options/FairMQProgOptions.h
@@ -155,6 +157,7 @@ set(FAIRMQ_SOURCE_FILES
   zeromq/FairMQUnmanagedRegionZMQ.cxx
   zeromq/FairMQSocketZMQ.cxx
   zeromq/FairMQTransportFactoryZMQ.cxx
+  MemoryResources.cxx
 )
 
 if(BUILD_NANOMSG_TRANSPORT)
@@ -232,6 +235,7 @@ endif()
 
 target_link_libraries(${_target}
   INTERFACE # only consumers link against interface dependencies
+  Boost::container
 
   PUBLIC # libFairMQ AND consumers of libFairMQ link aginst public dependencies
   Threads::Threads

fairmq/FairMQChannel.h

@@ -14,6 +14,7 @@
 #include <vector>
 #include <atomic>
 #include <mutex>
+#include <stdexcept>
 
 #include <FairMQTransportFactory.h>
 #include <FairMQSocket.h>
@@ -51,7 +52,9 @@ class FairMQChannel
     /// Default destructor
     virtual ~FairMQChannel();
 
-    FairMQSocket const & GetSocket() const;
+    struct ChannelConfigurationError : std::runtime_error { using std::runtime_error::runtime_error; };
+
+    FairMQSocket& GetSocket() const;
 
     auto Bind(const std::string& address) -> bool
     {
@@ -111,6 +114,10 @@ class FairMQChannel
     /// @return Returns socket kernel transmit receive buffer size (in bytes)
     int GetRcvKernelSize() const;
 
+    /// Get linger duration (in milliseconds)
+    /// @return Returns linger duration (in milliseconds)
+    int GetLinger() const;
+
     /// Get socket rate logging interval (in seconds)
     /// @return Returns socket rate logging interval (in seconds)
     int GetRateLogging() const;
@@ -147,6 +154,10 @@ class FairMQChannel
     /// @param rcvKernelSize Socket receive buffer size (in bytes)
     void UpdateRcvKernelSize(const int rcvKernelSize);
 
+    /// Set linger duration (in milliseconds)
+    /// @param duration linger duration (in milliseconds)
+    void UpdateLinger(const int duration);
+
     /// Set socket rate logging interval (in seconds)
     /// @param rateLogging Socket rate logging interval (in seconds)
     void UpdateRateLogging(const int rateLogging);
@@ -166,106 +177,62 @@ class FairMQChannel
     /// Resets the channel (requires validation to be used again).
     void ResetChannel();
 
-    int Send(FairMQMessagePtr& msg) const;
-    int Receive(FairMQMessagePtr& msg) const;
-
     /// Sends a message to the socket queue.
-    /// @details Send method attempts to send a message by
-    /// putting it in the output queue. If the queue is full or queueing is not possible
-    /// for some other reason (e.g. no peers connected for a binding socket), the method blocks.
-    ///
     /// @param msg Constant reference of unique_ptr to a FairMQMessage
-    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out.
-    /// In case of errors, returns -1.
-    int Send(FairMQMessagePtr& msg, int sndTimeoutInMs) const;
+    /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
+    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out. -1 if there was an error.
+    int Send(FairMQMessagePtr& msg, int sndTimeoutInMs = -1);
 
     /// Receives a message from the socket queue.
-    /// @details Receive method attempts to receive a message from the input queue.
-    /// If the queue is empty the method blocks.
-    ///
     /// @param msg Constant reference of unique_ptr to a FairMQMessage
-    /// @return Number of bytes that have been received. -2 If reading from the queue was not possible or timed out.
-    /// In case of errors, returns -1.
-    int Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs) const;
+    /// @param rcvTimeoutInMs receive timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
+    /// @return Number of bytes that have been received. -2 if reading from the queue was not possible or timed out. -1 if there was an error.
+    int Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs = -1);
 
-    /// Sends a message in non-blocking mode.
-    /// @details SendAsync method attempts to send a message without blocking by
-    /// putting it in the queue.
-    ///
-    /// @param msg Constant reference of unique_ptr to a FairMQMessage
-    /// @return Number of bytes that have been queued. If queueing failed due to
-    /// full queue or no connected peers (when binding), returns -2.
-    /// In case of errors, returns -1.
-    int SendAsync(FairMQMessagePtr& msg) const;
-
-    /// Receives a message in non-blocking mode.
-    ///
-    /// @param msg Constant reference of unique_ptr to a FairMQMessage
-    /// @return Number of bytes that have been received. If queue is empty, returns -2.
-    /// In case of errors, returns -1.
-    int ReceiveAsync(FairMQMessagePtr& msg) const;
-
-    int64_t Send(std::vector<FairMQMessagePtr>& msgVec) const;
-    int64_t Receive(std::vector<FairMQMessagePtr>& msgVec) const;
+    int SendAsync(FairMQMessagePtr& msg) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(msg, timeout);")));
+    int ReceiveAsync(FairMQMessagePtr& msg) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msg, timeout);")));
 
     /// Send a vector of messages
-    ///
     /// @param msgVec message vector reference
-    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out.
-    /// In case of errors, returns -1.
-    int64_t Send(std::vector<FairMQMessagePtr>& msgVec, int sndTimeoutInMs) const;
+    /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
+    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out. -1 if there was an error.
+    int64_t Send(std::vector<FairMQMessagePtr>& msgVec, int sndTimeoutInMs = -1);
 
     /// Receive a vector of messages
-    ///
     /// @param msgVec message vector reference
-    /// @return Number of bytes that have been received. -2 If reading from the queue was not possible or timed out.
-    /// In case of errors, returns -1.
-    int64_t Receive(std::vector<FairMQMessagePtr>& msgVec, int rcvTimeoutInMs) const;
+    /// @param rcvTimeoutInMs receive timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
+    /// @return Number of bytes that have been received. -2 if reading from the queue was not possible or timed out. -1 if there was an error.
+    int64_t Receive(std::vector<FairMQMessagePtr>& msgVec, int rcvTimeoutInMs = -1);
 
-    /// Sends a vector of message in non-blocking mode.
-    /// @details SendAsync method attempts to send a vector of messages without blocking by
-    /// putting it them the queue.
-    ///
-    /// @param msgVec message vector reference
-    /// @return Number of bytes that have been queued. If queueing failed due to
-    /// full queue or no connected peers (when binding), returns -2. In case of errors, returns -1.
-    int64_t SendAsync(std::vector<FairMQMessagePtr>& msgVec) const;
+    int64_t SendAsync(std::vector<FairMQMessagePtr>& msgVec) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(msgVec, timeout);")));
+    int64_t ReceiveAsync(std::vector<FairMQMessagePtr>& msgVec) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msgVec, timeout);")));
 
-    /// Receives a vector of messages in non-blocking mode.
-    ///
-    /// @param msgVec message vector reference
-    /// @return Number of bytes that have been received. If queue is empty, returns -2.
-    /// In case of errors, returns -1.
-    int64_t ReceiveAsync(std::vector<FairMQMessagePtr>& msgVec) const;
-
-    int64_t Send(FairMQParts& parts) const
-    {
-        return Send(parts.fParts);
-    }
-
-    int64_t Receive(FairMQParts& parts) const
-    {
-        return Receive(parts.fParts);
-    }
-
-    int64_t Send(FairMQParts& parts, int sndTimeoutInMs) const
+    /// Send FairMQParts
+    /// @param parts FairMQParts reference
+    /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
+    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out. -1 if there was an error.
+    int64_t Send(FairMQParts& parts, int sndTimeoutInMs = -1)
     {
         return Send(parts.fParts, sndTimeoutInMs);
     }
 
-    int64_t Receive(FairMQParts& parts, int rcvTimeoutInMs) const
+    /// Receive FairMQParts
+    /// @param parts FairMQParts reference
+    /// @param rcvTimeoutInMs receive timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
+    /// @return Number of bytes that have been received. -2 if reading from the queue was not possible or timed out. -1 if there was an error.
+    int64_t Receive(FairMQParts& parts, int rcvTimeoutInMs = -1)
     {
         return Receive(parts.fParts, rcvTimeoutInMs);
     }
 
-    int64_t SendAsync(FairMQParts& parts) const
+    int64_t SendAsync(FairMQParts& parts) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(parts, timeout);")))
     {
-        return SendAsync(parts.fParts);
+        return Send(parts.fParts, 0);
     }
 
-    int64_t ReceiveAsync(FairMQParts& parts) const
+    int64_t ReceiveAsync(FairMQParts& parts) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(parts, timeout);")))
     {
-        return ReceiveAsync(parts.fParts);
+        return Receive(parts.fParts, 0);
     }
 
     unsigned long GetBytesTx() const;
@@ -273,25 +240,25 @@ class FairMQChannel
     unsigned long GetMessagesTx() const;
     unsigned long GetMessagesRx() const;
 
-    auto Transport() const -> const FairMQTransportFactory*
+    auto Transport() -> FairMQTransportFactory*
     {
         return fTransportFactory.get();
     };
 
     template<typename... Args>
-    FairMQMessagePtr NewMessage(Args&&... args) const
+    FairMQMessagePtr NewMessage(Args&&... args)
     {
         return Transport()->CreateMessage(std::forward<Args>(args)...);
     }
 
     template<typename T>
-    FairMQMessagePtr NewSimpleMessage(const T& data) const
+    FairMQMessagePtr NewSimpleMessage(const T& data)
     {
         return Transport()->NewSimpleMessage(data);
     }
 
     template<typename T>
-    FairMQMessagePtr NewStaticMessage(const T& data) const
+    FairMQMessagePtr NewStaticMessage(const T& data)
     {
         return Transport()->NewStaticMessage(data);
     }
@@ -307,6 +274,7 @@ class FairMQChannel
     int fRcvBufSize;
     int fSndKernelSize;
     int fRcvKernelSize;
+    int fLinger;
     int fRateLogging;
 
     std::string fName;
@@ -314,10 +282,10 @@ class FairMQChannel
 
     std::shared_ptr<FairMQTransportFactory> fTransportFactory;
 
-    void CheckSendCompatibility(FairMQMessagePtr& msg) const;
-    void CheckSendCompatibility(std::vector<FairMQMessagePtr>& msgVec) const;
-    void CheckReceiveCompatibility(FairMQMessagePtr& msg) const;
-    void CheckReceiveCompatibility(std::vector<FairMQMessagePtr>& msgVec) const;
+    void CheckSendCompatibility(FairMQMessagePtr& msg);
+    void CheckSendCompatibility(std::vector<FairMQMessagePtr>& msgVec);
+    void CheckReceiveCompatibility(FairMQMessagePtr& msg);
+    void CheckReceiveCompatibility(std::vector<FairMQMessagePtr>& msgVec);
 
     void InitTransport(std::shared_ptr<FairMQTransportFactory> factory);
 

fairmq/FairMQDevice.cxx

@@ -16,7 +16,6 @@
 
 #include <list>
 #include <cstdlib>
-#include <stdexcept>
 #include <random>
 #include <chrono>
 #include <mutex>
@@ -56,9 +55,6 @@ FairMQDevice::FairMQDevice(FairMQProgOptions* config, const fair::mq::tools::Ver
     , fInternalConfig(config ? nullptr : fair::mq::tools::make_unique<FairMQProgOptions>())
     , fConfig(config ? config : fInternalConfig.get())
     , fId()
-    , fInitialValidationFinished(false)
-    , fInitialValidationCondition()
-    , fInitialValidationMutex()
     , fPortRangeMin(22000)
     , fPortRangeMax(32000)
     , fDefaultTransportType(fair::mq::Transport::DEFAULT)
@@ -76,6 +72,7 @@ FairMQDevice::FairMQDevice(FairMQProgOptions* config, const fair::mq::tools::Ver
     , fInterrupted(false)
     , fInterruptedCV()
     , fInterruptedMtx()
+    , fRateLogging(true)
 {
 }
 
@@ -86,13 +83,12 @@ void FairMQDevice::InitWrapper()
     fPortRangeMin = fConfig->GetValue<int>("port-range-min");
     fPortRangeMax = fConfig->GetValue<int>("port-range-max");
 
-    try
-    {
+    try {
         fDefaultTransportType = fair::mq::TransportTypes.at(fConfig->GetValue<string>("transport"));
-    }
-    catch (const exception& e)
-    {
+    } catch (const exception& e) {
+        LOG(error) << "exception: " << e.what();
         LOG(error) << "invalid transport type provided: " << fConfig->GetValue<string>("transport");
+        throw;
     }
 
     for (auto& c : fConfig->GetFairMQMap())
@@ -159,9 +155,8 @@ void FairMQDevice::InitWrapper()
                 }
                 else
                 {
-                    LOG(error) << "Cannot update configuration. Socket method (bind/connect) not specified.";
-                    ChangeState(ERROR_FOUND);
-                    // throw runtime_error("Cannot update configuration. Socket method (bind/connect) not specified.");
+                    LOG(error) << "Cannot update configuration. Socket method (bind/connect) for channel '" << vi->fName << "' not specified.";
+                    throw runtime_error(fair::mq::tools::ToString("Cannot update configuration. Socket method (bind/connect) for channel ", vi->fName, " not specified."));
                 }
             // }
         }
@@ -171,22 +166,14 @@ void FairMQDevice::InitWrapper()
     // If necessary this could be handled in the same way as the connecting channels
     AttachChannels(uninitializedBindingChannels);
 
-    if (uninitializedBindingChannels.size() > 0)
+    if (!uninitializedBindingChannels.empty())
     {
         LOG(error) << uninitializedBindingChannels.size() << " of the binding channels could not initialize. Initial configuration incomplete.";
-        ChangeState(ERROR_FOUND);
-        // throw runtime_error(fair::mq::tools::ToString(uninitializedBindingChannels.size(), " of the binding channels could not initialize. Initial configuration incomplete."));
+        throw runtime_error(fair::mq::tools::ToString(uninitializedBindingChannels.size(), " of the binding channels could not initialize. Initial configuration incomplete."));
     }
 
     CallStateChangeCallbacks(INITIALIZING_DEVICE);
 
-    // notify parent thread about completion of first validation.
-    {
-        lock_guard<mutex> lock(fInitialValidationMutex);
-        fInitialValidationFinished = true;
-        fInitialValidationCondition.notify_one();
-    }
-
     int initializationTimeoutInS = fConfig->GetValue<int>("initialization-timeout");
 
     // go over the list of channels until all are initialized (and removed from the uninitialized list)
@@ -200,24 +187,20 @@ void FairMQDevice::InitWrapper()
     {
         this_thread::sleep_for(chrono::milliseconds(sleepTimeInMS));
 
-        if (fConfig)
+        for (auto& chan : uninitializedConnectingChannels)
         {
-            for (auto& chan : uninitializedConnectingChannels)
+            string key{"chans." + chan->GetChannelPrefix() + "." + chan->GetChannelIndex() + ".address"};
+            string newAddress = fConfig->GetValue<string>(key);
+            if (newAddress != chan->GetAddress())
             {
-                string key{"chans." + chan->GetChannelPrefix() + "." + chan->GetChannelIndex() + ".address"};
-                string newAddress = fConfig->GetValue<string>(key);
-                if (newAddress != chan->GetAddress())
-                {
-                    chan->UpdateAddress(newAddress);
-                }
+                chan->UpdateAddress(newAddress);
             }
         }
 
         if (numAttempts++ > maxAttempts)
         {
             LOG(error) << "could not connect all channels after " << initializationTimeoutInS << " attempts";
-            ChangeState(ERROR_FOUND);
-            // throw runtime_error(fair::mq::tools::ToString("could not connect all channels after ", initializationTimeoutInS, " attempts"));
+            throw runtime_error(fair::mq::tools::ToString("could not connect all channels after ", initializationTimeoutInS, " attempts"));
         }
 
         AttachChannels(uninitializedConnectingChannels);
@@ -225,13 +208,11 @@ void FairMQDevice::InitWrapper()
 
     Init();
 
-    ChangeState(internal_DEVICE_READY);
-}
+    if (fChannels.empty()) {
+        LOG(warn) << "No channels created after finishing initialization";
+    }
 
-void FairMQDevice::WaitForInitialValidation()
-{
-    unique_lock<mutex> lock(fInitialValidationMutex);
-    fInitialValidationCondition.wait(lock, [&] () { return fInitialValidationFinished; });
+    ChangeState(internal_DEVICE_READY);
 }
 
 void FairMQDevice::Init()
@@ -295,18 +276,21 @@ bool FairMQDevice::AttachChannel(FairMQChannel& ch)
             }
         }
 
-        // set high water marks
-        ch.fSocket->SetOption("snd-hwm", &(ch.fSndBufSize), sizeof(ch.fSndBufSize));
-        ch.fSocket->SetOption("rcv-hwm", &(ch.fRcvBufSize), sizeof(ch.fRcvBufSize));
+        // set linger duration (how long socket should wait for outstanding transfers before shutdown)
+        ch.fSocket->SetLinger(ch.fLinger);
 
-        // set kernel transmit size
+        // set high water marks
+        ch.fSocket->SetSndBufSize(ch.fSndBufSize);
+        ch.fSocket->SetRcvBufSize(ch.fRcvBufSize);
+
+        // set kernel transmit size (set it only if value is not the default value)
         if (ch.fSndKernelSize != 0)
         {
-            ch.fSocket->SetOption("snd-size", &(ch.fSndKernelSize), sizeof(ch.fSndKernelSize));
+            ch.fSocket->SetSndKernelSize(ch.fSndKernelSize);
         }
         if (ch.fRcvKernelSize != 0)
         {
-            ch.fSocket->SetOption("rcv-size", &(ch.fRcvKernelSize), sizeof(ch.fRcvKernelSize));
+            ch.fSocket->SetRcvKernelSize(ch.fRcvKernelSize);
         }
 
         // attach
@@ -331,7 +315,7 @@ bool FairMQDevice::AttachChannel(FairMQChannel& ch)
         if (address.compare(0, 6, "tcp://") == 0)
         {
             string addressString = address.substr(6);
-            auto pos = addressString.find(":");
+            auto pos = addressString.find(':');
             string hostPart = addressString.substr(0, pos);
             if (!(bind && hostPart == "*"))
             {
@@ -365,7 +349,7 @@ bool FairMQDevice::AttachChannel(FairMQChannel& ch)
         }
         endpoint += address;
 
-        LOG(debug) << "Attached channel " << ch.fName << " to " << endpoint << (bind ? " (bind) " : " (connect) ");
+        LOG(debug) << "Attached channel " << ch.fName << " to " << endpoint << (bind ? " (bind) " : " (connect) ") << "(" << ch.fType << ")";
 
         // after the book keeping is done, exit in case of errors
         if (!success)
@@ -379,11 +363,8 @@ bool FairMQDevice::AttachChannel(FairMQChannel& ch)
     if (newAddress != ch.fAddress)
     {
         ch.UpdateAddress(newAddress);
-        if (fConfig)
-        {
-            string key{"chans." + ch.GetChannelPrefix() + "." + ch.GetChannelIndex() + ".address"};
-            fConfig->SetValue(key, newAddress);
-        }
+        string key{"chans." + ch.GetChannelPrefix() + "." + ch.GetChannelIndex() + ".address"};
+        fConfig->SetValue(key, newAddress);
     }
 
     return true;
@@ -418,7 +399,7 @@ bool FairMQDevice::BindEndpoint(FairMQSocket& socket, string& endpoint)
             return false;
         }
 
-        size_t pos = endpoint.rfind(":");
+        size_t pos = endpoint.rfind(':');
         endpoint = endpoint.substr(0, pos + 1) + fair::mq::tools::ToString(static_cast<int>(randomPort(generator)));
     }
 
@@ -468,15 +449,15 @@ void FairMQDevice::PrintChannel(const string& name)
 {
     if (fChannels.find(name) != fChannels.end())
     {
-        for (auto vi = fChannels[name].begin(); vi != fChannels[name].end(); ++vi)
+        for (const auto& vi : fChannels[name])
         {
-            LOG(info) << vi->fName << ": "
-                      << vi->fType << " | "
-                      << vi->fMethod << " | "
-                      << vi->fAddress << " | "
-                      << vi->fSndBufSize << " | "
-                      << vi->fRcvBufSize << " | "
-                      << vi->fRateLogging;
+            LOG(info) << vi.fName << ": "
+                      << vi.fType << " | "
+                      << vi.fMethod << " | "
+                      << vi.fAddress << " | "
+                      << vi.fSndBufSize << " | "
+                      << vi.fRcvBufSize << " | "
+                      << vi.fRateLogging;
         }
     }
     else
@@ -492,6 +473,7 @@ void FairMQDevice::RunWrapper()
     LOG(info) << "DEVICE: Running...";
 
     // start the rate logger thread
+    fRateLogging = true;
     future<void> rateLogger = async(launch::async, &FairMQDevice::LogSocketRates, this);
 
     // notify transports to resume transfers
@@ -504,8 +486,7 @@ void FairMQDevice::RunWrapper()
         t.second->Resume();
     }
 
-    try
-    {
+    try {
         PreRun();
 
         // process either data callbacks or ConditionalRun/Run
@@ -535,11 +516,14 @@ void FairMQDevice::RunWrapper()
 
             Run();
         }
-    }
-    catch (const out_of_range& oor)
-    {
+    } catch (const out_of_range& oor) {
         LOG(error) << "out of range: " << oor.what();
         LOG(error) << "incorrect/incomplete channel configuration?";
+        fRateLogging = false;
+        throw;
+    } catch (...) {
+        fRateLogging = false;
+        throw;
     }
 
     // if Run() exited and the state is still RUNNING, transition to READY.
@@ -593,17 +577,17 @@ void FairMQDevice::HandleMultipleChannelInput()
 
     for (const auto& mi : fMsgInputs)
     {
-        for (unsigned int i = 0; i < fChannels.at(mi.first).size(); ++i)
+        for (auto& i : fChannels.at(mi.first))
         {
-            fChannels.at(mi.first).at(i).fMultipart = false;
+            i.fMultipart = false;
         }
     }
 
     for (const auto& mi : fMultipartInputs)
     {
-        for (unsigned int i = 0; i < fChannels.at(mi.first).size(); ++i)
+        for (auto& i : fChannels.at(mi.first))
         {
-            fChannels.at(mi.first).at(i).fMultipart = true;
+            i.fMultipart = true;
         }
     }
 
@@ -661,7 +645,7 @@ void FairMQDevice::HandleMultipleTransportInput()
 
     for (const auto& i : fMultitransportInputs)
     {
-        threads.push_back(thread(&FairMQDevice::PollForTransport, this, fTransports.at(i.first).get(), i.second));
+        threads.emplace_back(thread(&FairMQDevice::PollForTransport, this, fTransports.at(i.first).get(), i.second));
     }
 
     for (thread& t : threads)
@@ -718,11 +702,11 @@ void FairMQDevice::PollForTransport(const FairMQTransportFactory* factory, const
     catch (exception& e)
     {
         LOG(error) << "FairMQDevice::PollForTransport() failed: " << e.what() << ", going to ERROR state.";
-        ChangeState(ERROR_FOUND);
+        throw runtime_error(fair::mq::tools::ToString("FairMQDevice::PollForTransport() failed: ", e.what(), ", going to ERROR state."));
     }
 }
 
-bool FairMQDevice::HandleMsgInput(const string& chName, const InputMsgCallback& callback, int i) const
+bool FairMQDevice::HandleMsgInput(const string& chName, const InputMsgCallback& callback, int i)
 {
     unique_ptr<FairMQMessage> input(fChannels.at(chName).at(i).fTransportFactory->CreateMessage());
 
@@ -736,7 +720,7 @@ bool FairMQDevice::HandleMsgInput(const string& chName, const InputMsgCallback&
     }
 }
 
-bool FairMQDevice::HandleMultipartInput(const string& chName, const InputMultipartCallback& callback, int i) const
+bool FairMQDevice::HandleMultipartInput(const string& chName, const InputMultipartCallback& callback, int i)
 {
     FairMQParts input;
 
@@ -874,7 +858,7 @@ void FairMQDevice::LogSocketRates()
 
         LOG(debug) << "<channel>: in: <#msgs> (<MB>) out: <#msgs> (<MB>)";
 
-        while (CheckCurrentState(RUNNING))
+        while (fRateLogging)
         {
             t1 = chrono::high_resolution_clock::now();
 
@@ -914,8 +898,7 @@ void FairMQDevice::LogSocketRates()
             }
 
             t0 = t1;
-            this_thread::sleep_for(chrono::milliseconds(1000));
-            // WaitFor(chrono::milliseconds(1000)); TODO: enable this when nanomsg linger is fixed
+            WaitFor(chrono::milliseconds(1000));
         }
     }
 }
@@ -929,6 +912,7 @@ void FairMQDevice::Unblock()
     {
         lock_guard<mutex> guard(fInterruptedMtx);
         fInterrupted = true;
+        fRateLogging = false;
     }
     fInterruptedCV.notify_all();
 }
@@ -950,13 +934,11 @@ void FairMQDevice::ResetWrapper()
 {
     CallStateChangeCallbacks(RESETTING_DEVICE);
 
-    Reset();
+    for (auto& t : fTransports)
+    {
+        t.second->Reset();
+    }
 
-    ChangeState(internal_IDLE);
-}
-
-void FairMQDevice::Reset()
-{
     // iterate over the channels map
     for (auto& mi : fChannels)
     {
@@ -967,11 +949,14 @@ void FairMQDevice::Reset()
             vi.fSocket.reset(); // destroy FairMQSocket
         }
     }
+
+    Reset();
+
+    ChangeState(internal_IDLE);
 }
 
-const FairMQChannel& FairMQDevice::GetChannel(const string& channelName, const int index) const
+void FairMQDevice::Reset()
 {
-    return fChannels.at(channelName).at(index);
 }
 
 void FairMQDevice::Exit()

fairmq/FairMQDevice.h

@@ -31,6 +31,7 @@
 #include <functional>
 #include <assert.h> // static_assert
 #include <type_traits> // is_trivially_copyable
+#include <stdexcept>
 
 #include <mutex>
 #include <condition_variable>
@@ -96,154 +97,108 @@ class FairMQDevice : public FairMQStateMachine
         Deserializer().Deserialize(msg, std::forward<DataType>(data), std::forward<Args>(args)...);
     }
 
-    int Send(FairMQMessagePtr& msg, const std::string& chan, const int i = 0) const
-    {
-        return fChannels.at(chan).at(i).Send(msg);
-    }
-
-    int Receive(FairMQMessagePtr& msg, const std::string& chan, const int i = 0) const
-    {
-        return fChannels.at(chan).at(i).Receive(msg);
-    }
-
     /// Shorthand method to send `msg` on `chan` at index `i`
     /// @param msg message reference
     /// @param chan channel name
     /// @param i channel index
-    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out.
-    /// In case of errors, returns -1.
-    int Send(FairMQMessagePtr& msg, const std::string& chan, const int i, int sndTimeoutInMs) const
+    /// @param sndTimeoutInMs send timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
+    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out. -1 if there was an error.
+    int Send(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
     {
-        return fChannels.at(chan).at(i).Send(msg, sndTimeoutInMs);
+        return GetChannel(channel, index).Send(msg, sndTimeoutInMs);
     }
 
     /// Shorthand method to receive `msg` on `chan` at index `i`
     /// @param msg message reference
     /// @param chan channel name
     /// @param i channel index
-    /// @return Number of bytes that have been received. -2 If reading from the queue was not possible or timed out.
-    /// In case of errors, returns -1.
-    int Receive(FairMQMessagePtr& msg, const std::string& chan, const int i, int rcvTimeoutInMs) const
+    /// @param rcvTimeoutInMs receive timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
+    /// @return Number of bytes that have been received. -2 if reading from the queue was not possible or timed out. -1 if there was an error.
+    int Receive(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
     {
-        return fChannels.at(chan).at(i).Receive(msg, rcvTimeoutInMs);
+        return GetChannel(channel, index).Receive(msg, rcvTimeoutInMs);
     }
 
-    /// Shorthand method to send `msg` on `chan` at index `i` without blocking
-    /// @param msg message reference
-    /// @param chan channel name
-    /// @param i channel index
-    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out.
-    /// In case of errors, returns -1.
-    int SendAsync(FairMQMessagePtr& msg, const std::string& chan, const int i = 0) const
+    int SendAsync(FairMQMessagePtr& msg, const std::string& channel, const int index = 0) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(msg, \"channelA\", subchannelIndex, timeout);")))
     {
-        return fChannels.at(chan).at(i).SendAsync(msg);
+        return GetChannel(channel, index).Send(msg, 0);
     }
-
-    /// Shorthand method to receive `msg` on `chan` at index `i` without blocking
-    /// @param msg message reference
-    /// @param chan channel name
-    /// @param i channel index
-    /// @return Number of bytes that have been received. -2 If reading from the queue was not possible or timed out.
-    /// In case of errors, returns -1.
-    int ReceiveAsync(FairMQMessagePtr& msg, const std::string& chan, const int i = 0) const
+    int ReceiveAsync(FairMQMessagePtr& msg, const std::string& channel, const int index = 0) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msg, \"channelA\", subchannelIndex, timeout);")))
     {
-        return fChannels.at(chan).at(i).ReceiveAsync(msg);
-    }
-
-    int64_t Send(FairMQParts& parts, const std::string& chan, const int i = 0) const
-    {
-        return fChannels.at(chan).at(i).Send(parts.fParts);
-    }
-
-    int64_t Receive(FairMQParts& parts, const std::string& chan, const int i = 0) const
-    {
-        return fChannels.at(chan).at(i).Receive(parts.fParts);
+        return GetChannel(channel, index).Receive(msg, 0);
     }
 
     /// Shorthand method to send FairMQParts on `chan` at index `i`
     /// @param parts parts reference
     /// @param chan channel name
     /// @param i channel index
-    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out.
-    /// In case of errors, returns -1.
-    int64_t Send(FairMQParts& parts, const std::string& chan, const int i, int sndTimeoutInMs) const
+    /// @param sndTimeoutInMs send timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
+    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out. -1 if there was an error.
+    int64_t Send(FairMQParts& parts, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
     {
-        return fChannels.at(chan).at(i).Send(parts.fParts, sndTimeoutInMs);
+        return GetChannel(channel, index).Send(parts.fParts, sndTimeoutInMs);
     }
 
     /// Shorthand method to receive FairMQParts on `chan` at index `i`
     /// @param parts parts reference
     /// @param chan channel name
     /// @param i channel index
-    /// @return Number of bytes that have been received. -2 If reading from the queue was not possible or timed out.
-    /// In case of errors, returns -1.
-    int64_t Receive(FairMQParts& parts, const std::string& chan, const int i, int rcvTimeoutInMs) const
+    /// @param rcvTimeoutInMs receive timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
+    /// @return Number of bytes that have been received. -2 if reading from the queue was not possible or timed out. -1 if there was an error.
+    int64_t Receive(FairMQParts& parts, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
     {
-        return fChannels.at(chan).at(i).Receive(parts.fParts, rcvTimeoutInMs);
+        return GetChannel(channel, index).Receive(parts.fParts, rcvTimeoutInMs);
     }
 
-    /// Shorthand method to send FairMQParts on `chan` at index `i` without blocking
-    /// @param parts parts reference
-    /// @param chan channel name
-    /// @param i channel index
-    /// @return Number of bytes that have been queued. -2 If queueing was not possible or timed out.
-    /// In case of errors, returns -1.
-    int64_t SendAsync(FairMQParts& parts, const std::string& chan, const int i = 0) const
+    int64_t SendAsync(FairMQParts& parts, const std::string& channel, const int index = 0) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(parts, \"channelA\", subchannelIndex, timeout);")))
     {
-        return fChannels.at(chan).at(i).SendAsync(parts.fParts);
+        return GetChannel(channel, index).Send(parts.fParts, 0);
     }
-
-    /// Shorthand method to receive FairMQParts on `chan` at index `i` without blocking
-    /// @param parts parts reference
-    /// @param chan channel name
-    /// @param i channel index
-    /// @return Number of bytes that have been received. -2 If reading from the queue was not possible or timed out.
-    /// In case of errors, returns -1.
-    int64_t ReceiveAsync(FairMQParts& parts, const std::string& chan, const int i = 0) const
+    int64_t ReceiveAsync(FairMQParts& parts, const std::string& channel, const int index = 0) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(parts, \"channelA\", subchannelIndex, timeout);")))
     {
-        return fChannels.at(chan).at(i).ReceiveAsync(parts.fParts);
+        return GetChannel(channel, index).Receive(parts.fParts, 0);
     }
 
     /// @brief Getter for default transport factory
-    auto Transport() const -> const FairMQTransportFactory*
+    auto Transport() const -> FairMQTransportFactory*
     {
         return fTransportFactory.get();
     }
 
     template<typename... Args>
-    FairMQMessagePtr NewMessage(Args&&... args) const
+    FairMQMessagePtr NewMessage(Args&&... args)
     {
         return Transport()->CreateMessage(std::forward<Args>(args)...);
     }
 
     template<typename... Args>
-    FairMQMessagePtr NewMessageFor(const std::string& channel, int index, Args&&... args) const
+    FairMQMessagePtr NewMessageFor(const std::string& channel, int index, Args&&... args)
     {
-        return fChannels.at(channel).at(index).NewMessage(std::forward<Args>(args)...);
+        return GetChannel(channel, index).NewMessage(std::forward<Args>(args)...);
     }
 
     template<typename T>
-    FairMQMessagePtr NewStaticMessage(const T& data) const
+    FairMQMessagePtr NewStaticMessage(const T& data)
     {
         return Transport()->NewStaticMessage(data);
     }
 
     template<typename T>
-    FairMQMessagePtr NewStaticMessageFor(const std::string& channel, int index, const T& data) const
+    FairMQMessagePtr NewStaticMessageFor(const std::string& channel, int index, const T& data)
     {
-        return fChannels.at(channel).at(index).NewStaticMessage(data);
+        return GetChannel(channel, index).NewStaticMessage(data);
     }
 
     template<typename T>
-    FairMQMessagePtr NewSimpleMessage(const T& data) const
+    FairMQMessagePtr NewSimpleMessage(const T& data)
     {
         return Transport()->NewSimpleMessage(data);
     }
 
     template<typename T>
-    FairMQMessagePtr NewSimpleMessageFor(const std::string& channel, int index, const T& data) const
+    FairMQMessagePtr NewSimpleMessageFor(const std::string& channel, int index, const T& data)
     {
-        return fChannels.at(channel).at(index).NewSimpleMessage(data);
+        return GetChannel(channel, index).NewSimpleMessage(data);
     }
 
     FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size)
@@ -253,7 +208,7 @@ class FairMQDevice : public FairMQStateMachine
 
     FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel, int index, const size_t size, FairMQRegionCallback callback = nullptr)
     {
-        return fChannels.at(channel).at(index).Transport()->CreateUnmanagedRegion(size, callback);
+        return GetChannel(channel, index).Transport()->CreateUnmanagedRegion(size, callback);
     }
 
     template<typename ...Ts>
@@ -264,22 +219,22 @@ class FairMQDevice : public FairMQStateMachine
         // if more than one channel provided, check compatibility
         if (chans.size() > 1)
         {
-            fair::mq::Transport type = fChannels.at(chans.at(0)).at(0).Transport()->GetType();
+            fair::mq::Transport type = GetChannel(chans.at(0), 0).Transport()->GetType();
 
             for (unsigned int i = 1; i < chans.size(); ++i)
             {
-                if (type != fChannels.at(chans.at(i)).at(0).Transport()->GetType())
+                if (type != GetChannel(chans.at(i), 0).Transport()->GetType())
                 {
                     LOG(error) << "poller failed: different transports within same poller are not yet supported. Going to ERROR state.";
-                    ChangeState(ERROR_FOUND);
+                    throw std::runtime_error("poller failed: different transports within same poller are not yet supported.");
                 }
             }
         }
 
-        return fChannels.at(chans.at(0)).at(0).Transport()->CreatePoller(fChannels, chans);
+        return GetChannel(chans.at(0), 0).Transport()->CreatePoller(fChannels, chans);
     }
 
-    FairMQPollerPtr NewPoller(const std::vector<const FairMQChannel*>& channels)
+    FairMQPollerPtr NewPoller(const std::vector<FairMQChannel*>& channels)
     {
         // if more than one channel provided, check compatibility
         if (channels.size() > 1)
@@ -291,7 +246,7 @@ class FairMQDevice : public FairMQStateMachine
                 if (type != channels.at(i)->Transport()->GetType())
                 {
                     LOG(error) << "poller failed: different transports within same poller are not yet supported. Going to ERROR state.";
-                    ChangeState(ERROR_FOUND);
+                    throw std::runtime_error("poller failed: different transports within same poller are not yet supported.");
                 }
             }
         }
@@ -300,7 +255,7 @@ class FairMQDevice : public FairMQStateMachine
     }
 
     /// Waits for the first initialization run to finish
-    void WaitForInitialValidation();
+    void WaitForInitialValidation() __attribute__((deprecated("This method will have no effect in future versions and will be removed. Instead subscribe for state changes and inspect configuration values."))) {}
 
     /// Adds a transport to the device if it doesn't exist
     /// @param transport  Transport string ("zeromq"/"nanomsg"/"shmem")
@@ -319,6 +274,7 @@ class FairMQDevice : public FairMQStateMachine
     /// @param rhs Left hand side value for comparison
     static bool SortSocketsByAddress(const FairMQChannel &lhs, const FairMQChannel &rhs);
 
+    // overload to easily bind member functions
     template<typename T>
     void OnData(const std::string& channelName, bool (T::* memberFunction)(FairMQMessagePtr& msg, int index))
     {
@@ -345,6 +301,7 @@ class FairMQDevice : public FairMQStateMachine
         }
     }
 
+    // overload to easily bind member functions
     template<typename T>
     void OnData(const std::string& channelName, bool (T::* memberFunction)(FairMQParts& parts, int index))
     {
@@ -371,7 +328,15 @@ class FairMQDevice : public FairMQStateMachine
         }
     }
 
-    const FairMQChannel& GetChannel(const std::string& channelName, const int index = 0) const;
+    FairMQChannel& GetChannel(const std::string& channelName, const int index = 0)
+    try {
+        return fChannels.at(channelName).at(index);
+    } catch (const std::out_of_range& oor) {
+        LOG(error) << "out of range: " << oor.what();
+        LOG(error) << "requested channel has not been configured? check channel names/configuration.";
+        fRateLogging = false;
+        throw;
+    }
 
     virtual void RegisterChannelEndpoints() {}
 
@@ -432,7 +397,11 @@ class FairMQDevice : public FairMQStateMachine
     void SetRawCmdLineArgs(const std::vector<std::string>& args) { fRawCmdLineArgs = args; }
     std::vector<std::string> GetRawCmdLineArgs() const { return fRawCmdLineArgs; }
 
-    void RunStateMachine() { ProcessWork(); };
+    void RunStateMachine()
+    {
+      CallStateChangeCallbacks(FairMQStateMachine::IDLE);
+      ProcessWork();
+    };
 
     /// Wait for the supplied amount of time or for interruption.
     /// If interrupted, returns false, otherwise true.
@@ -489,11 +458,6 @@ class FairMQDevice : public FairMQStateMachine
     virtual void Reset();
 
   private:
-    // condition variable to notify parent thread about end of initial validation.
-    bool fInitialValidationFinished;
-    std::condition_variable fInitialValidationCondition;
-    std::mutex fInitialValidationMutex;
-
     int fPortRangeMin; ///< Minimum value for the port range (if dynamic)
     int fPortRangeMax; ///< Maximum value for the port range (if dynamic)
 
@@ -536,8 +500,8 @@ class FairMQDevice : public FairMQStateMachine
     void HandleMultipleTransportInput();
     void PollForTransport(const FairMQTransportFactory* factory, const std::vector<std::string>& channelKeys);
 
-    bool HandleMsgInput(const std::string& chName, const InputMsgCallback& callback, int i) const;
-    bool HandleMultipartInput(const std::string& chName, const InputMultipartCallback& callback, int i) const;
+    bool HandleMsgInput(const std::string& chName, const InputMsgCallback& callback, int i);
+    bool HandleMultipartInput(const std::string& chName, const InputMultipartCallback& callback, int i);
 
     void CreateOwnConfig();
 
@@ -557,6 +521,7 @@ class FairMQDevice : public FairMQStateMachine
     std::atomic<bool> fInterrupted;
     std::condition_variable fInterruptedCV;
     std::mutex fInterruptedMtx;
+    mutable std::atomic<bool> fRateLogging;
 };
 
 #endif /* FAIRMQDEVICE_H_ */

fairmq/FairMQMessage.h

@@ -15,10 +15,13 @@
 #include <fairmq/Transports.h>
 
 using fairmq_free_fn = void(void* data, void* hint);
+class FairMQTransportFactory;
 
 class FairMQMessage
 {
   public:
+    FairMQMessage() = default;
+    FairMQMessage(FairMQTransportFactory* factory):fTransport{factory} {}
     virtual void Rebuild() = 0;
     virtual void Rebuild(const size_t size) = 0;
     virtual void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) = 0;
@@ -29,11 +32,16 @@ class FairMQMessage
     virtual bool SetUsedSize(const size_t size) = 0;
 
     virtual fair::mq::Transport GetType() const = 0;
+    FairMQTransportFactory* GetTransport() { return fTransport; }
+    //void SetTransport(FairMQTransportFactory* transport) { fTransport = transport; }
 
     virtual void Copy(const std::unique_ptr<FairMQMessage>& msg) __attribute__((deprecated("Use 'Copy(const FairMQMessage& msg)'"))) = 0;
     virtual void Copy(const FairMQMessage& msg) = 0;
 
     virtual ~FairMQMessage() {};
+
+  private:
+    FairMQTransportFactory* fTransport{nullptr};
 };
 
 using FairMQMessagePtr = std::unique_ptr<FairMQMessage>;

fairmq/FairMQSocket.h

@@ -25,34 +25,32 @@ class FairMQSocket
     virtual bool Bind(const std::string& address) = 0;
     virtual void Connect(const std::string& address) = 0;
 
-    virtual int Send(FairMQMessagePtr& msg, int timeout = 0) = 0;
-    virtual int Receive(FairMQMessagePtr& msg, int timeout = 0) = 0;
-    virtual int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = 0) = 0;
-    virtual int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = 0) = 0;
-
-    virtual int TrySend(FairMQMessagePtr& msg) = 0;
-    virtual int TryReceive(FairMQMessagePtr& msg) = 0;
-    virtual int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0;
-    virtual int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) = 0;
-
-    virtual void* GetSocket() const = 0;
-    virtual int GetSocket(int nothing) const = 0;
+    virtual int Send(FairMQMessagePtr& msg, int timeout = -1) = 0;
+    virtual int Receive(FairMQMessagePtr& msg, int timeout = -1) = 0;
+    virtual int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = -1) = 0;
+    virtual int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = -1) = 0;
 
     virtual void Close() = 0;
 
     virtual void SetOption(const std::string& option, const void* value, size_t valueSize) = 0;
     virtual void GetOption(const std::string& option, void* value, size_t* valueSize) = 0;
 
+    virtual void SetLinger(const int value) = 0;
+    virtual int GetLinger() const = 0;
+    virtual void SetSndBufSize(const int value) = 0;
+    virtual int GetSndBufSize() const = 0;
+    virtual void SetRcvBufSize(const int value) = 0;
+    virtual int GetRcvBufSize() const = 0;
+    virtual void SetSndKernelSize(const int value) = 0;
+    virtual int GetSndKernelSize() const = 0;
+    virtual void SetRcvKernelSize(const int value) = 0;
+    virtual int GetRcvKernelSize() const = 0;
+
     virtual unsigned long GetBytesTx() const = 0;
     virtual unsigned long GetBytesRx() const = 0;
     virtual unsigned long GetMessagesTx() const = 0;
     virtual unsigned long GetMessagesRx() const = 0;
 
-    virtual bool SetSendTimeout(const int timeout, const std::string& address, const std::string& method) = 0;
-    virtual int GetSendTimeout() const = 0;
-    virtual bool SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method) = 0;
-    virtual int GetReceiveTimeout() const = 0;
-
     virtual ~FairMQSocket() {};
 };
 

fairmq/FairMQStateMachine.cxx

@@ -175,12 +175,13 @@ struct Machine_ : public state_machine_def<Machine_>
     using initial_state = boost::mpl::vector<IDLE_FSM_STATE, OK_FSM_STATE>;
 
     template<typename Event, typename FSM>
-    void on_entry(Event const&, FSM& fsm)
+    void on_entry(Event const&, FSM& /*fsm*/)
     {
         LOG(state) << "Starting FairMQ state machine";
         fState = FairMQStateMachine::IDLE;
         LOG(state) << "Entering IDLE state";
-        fsm.CallStateChangeCallbacks(FairMQStateMachine::IDLE);
+        // fsm.CallStateChangeCallbacks(FairMQStateMachine::IDLE);
+        // we call this for now in FairMQDevice::RunStateMachine()
     }
 
     template<typename Event, typename FSM>

fairmq/FairMQTransportFactory.h

@@ -9,11 +9,12 @@
 #ifndef FAIRMQTRANSPORTFACTORY_H_
 #define FAIRMQTRANSPORTFACTORY_H_
 
-#include <FairMQMessage.h>
-#include <FairMQSocket.h>
-#include <FairMQPoller.h>
-#include <FairMQUnmanagedRegion.h>
 #include <FairMQLogger.h>
+#include <FairMQMessage.h>
+#include <FairMQPoller.h>
+#include <FairMQSocket.h>
+#include <FairMQUnmanagedRegion.h>
+#include <fairmq/MemoryResources.h>
 #include <fairmq/Transports.h>
 
 #include <string>
@@ -30,6 +31,9 @@ class FairMQTransportFactory
     /// Topology wide unique id
     const std::string fkId;
 
+    /// The polymorphic memory resource associated with the transport
+    fair::mq::ChannelResource fMemoryResource{this};
+
   public:
     /// ctor
     /// @param id Topology wide unique id, usually the device id.
@@ -37,22 +41,25 @@ class FairMQTransportFactory
 
     auto GetId() const -> const std::string { return fkId; };
 
+    /// Get a pointer to the associated polymorphic memory resource
+    fair::mq::ChannelResource* GetMemoryResource() { return &fMemoryResource; }
+
     /// @brief Create empty FairMQMessage
     /// @return pointer to FairMQMessage
-    virtual FairMQMessagePtr CreateMessage() const = 0;
+    virtual FairMQMessagePtr CreateMessage() = 0;
     /// @brief Create new FairMQMessage of specified size
     /// @param size message size
     /// @return pointer to FairMQMessage
-    virtual FairMQMessagePtr CreateMessage(const size_t size) const = 0;
+    virtual FairMQMessagePtr CreateMessage(const size_t size) = 0;
     /// @brief Create new FairMQMessage with user provided buffer and size
     /// @param data pointer to user provided buffer
     /// @param size size of the user provided buffer
     /// @param ffn callback, called when the message is transfered (and can be deleted)
     /// @param obj optional helper pointer that can be used in the callback
     /// @return pointer to FairMQMessage
-    virtual FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const = 0;
+    virtual FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) = 0;
 
-    virtual FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& unmanagedRegion, void* data, const size_t size, void* hint = 0) const = 0;
+    virtual FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& unmanagedRegion, void* data, const size_t size, void* hint = 0) = 0;
 
     /// Create a socket
     virtual FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) const = 0;
@@ -60,11 +67,9 @@ class FairMQTransportFactory
     /// Create a poller for a single channel (all subchannels)
     virtual FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const = 0;
     /// Create a poller for specific channels
-    virtual FairMQPollerPtr CreatePoller(const std::vector<const FairMQChannel*>& channels) const = 0;
+    virtual FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const = 0;
     /// Create a poller for specific channels (all subchannels)
     virtual FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const = 0;
-    /// Create a poller for two sockets
-    virtual FairMQPollerPtr CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const = 0;
 
     virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr) const = 0;
 
@@ -73,6 +78,7 @@ class FairMQTransportFactory
 
     virtual void Interrupt() = 0;
     virtual void Resume() = 0;
+    virtual void Reset() = 0;
 
     virtual ~FairMQTransportFactory() {};
 
@@ -89,7 +95,7 @@ class FairMQTransportFactory
     }
 
     template<typename T>
-    FairMQMessagePtr NewSimpleMessage(const T& data) const
+    FairMQMessagePtr NewSimpleMessage(const T& data)
     {
         // todo: is_trivially_copyable not available on gcc < 5, workaround?
         // static_assert(std::is_trivially_copyable<T>::value, "The argument type for NewSimpleMessage has to be trivially copyable!");
@@ -98,13 +104,13 @@ class FairMQTransportFactory
     }
 
     template<std::size_t N>
-    FairMQMessagePtr NewSimpleMessage(const char(&data)[N]) const
+    FairMQMessagePtr NewSimpleMessage(const char(&data)[N])
     {
         std::string* msgStr = new std::string(data);
         return CreateMessage(const_cast<char*>(msgStr->c_str()), msgStr->length(), FairMQSimpleMsgCleanup<std::string>, msgStr);
     }
 
-    FairMQMessagePtr NewSimpleMessage(const std::string& str) const
+    FairMQMessagePtr NewSimpleMessage(const std::string& str)
     {
 
         std::string* msgStr = new std::string(str);
@@ -112,12 +118,12 @@ class FairMQTransportFactory
     }
 
     template<typename T>
-    FairMQMessagePtr NewStaticMessage(const T& data) const
+    FairMQMessagePtr NewStaticMessage(const T& data)
     {
         return CreateMessage(data, sizeof(T), FairMQNoCleanup, nullptr);
     }
 
-    FairMQMessagePtr NewStaticMessage(const std::string& str) const
+    FairMQMessagePtr NewStaticMessage(const std::string& str)
     {
         return CreateMessage(const_cast<char*>(str.c_str()), str.length(), FairMQNoCleanup, nullptr);
     }

fairmq/MemoryResourceTools.h

@@ -0,0 +1,60 @@
+/********************************************************************************
+ *    Copyright (C) 2018 CERN and copyright holders of ALICE O2 *
+ *    Copyright (C) 2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
+ *                                                                              *
+ *              This software is distributed under the terms of the *
+ *              GNU Lesser General Public Licence (LGPL) version 3, *
+ *                  copied verbatim in the file "LICENSE" *
+ ********************************************************************************/
+
+/// @brief Tools for interfacing containers to the transport via polymorphic
+/// allocators
+///
+/// @author Mikolaj Krzewicki, mkrzewic@cern.ch
+
+#include <fairmq/FairMQTransportFactory.h>
+#include <fairmq/MemoryResources.h>
+
+namespace fair {
+namespace mq {
+
+using BytePmrAllocator = pmr::polymorphic_allocator<fair::mq::byte>;
+
+//_________________________________________________________________________________________________
+// return the message associated with the container or throw if it is not possible
+template<typename ContainerT>
+// typename std::enable_if<
+//    std::is_base_of<
+//        pmr::polymorphic_allocator<typename
+//        ContainerT::value_type>,
+//        typename ContainerT::allocator_type>::value == true,
+//    FairMQMessagePtr>::type
+FairMQMessagePtr getMessage(ContainerT &&container_, FairMQMemoryResource *targetResource = nullptr)
+{
+    auto container = std::move(container_);
+    auto alloc = container.get_allocator();
+
+    auto resource = dynamic_cast<FairMQMemoryResource *>(alloc.resource());
+    if (!resource && !targetResource) {
+        throw std::runtime_error("Neither the container or target resource specified");
+    }
+    size_t containerSizeBytes = container.size() * sizeof(typename ContainerT::value_type);
+    if ((!targetResource && resource)
+        || (resource && targetResource && resource->is_equal(*targetResource))) {
+        auto message = resource->getMessage(static_cast<void *>(
+            const_cast<typename std::remove_const<typename ContainerT::value_type>::type *>(
+                container.data())));
+        if (message)
+            message->SetUsedSize(containerSizeBytes);
+        return message;
+    } else {
+        auto message = targetResource->getTransportFactory()->CreateMessage(containerSizeBytes);
+        std::memcpy(static_cast<fair::mq::byte *>(message->GetData()),
+                    container.data(),
+                    containerSizeBytes);
+        return message;
+    }
+};
+
+} /* namespace mq */
+} /* namespace fair */

fairmq/MemoryResources.cxx

@@ -0,0 +1,22 @@
+/********************************************************************************
+ *    Copyright (C) 2018 CERN and copyright holders of ALICE O2 *
+ *    Copyright (C) 2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
+ *                                                                              *
+ *              This software is distributed under the terms of the *
+ *              GNU Lesser General Public Licence (LGPL) version 3, *
+ *                  copied verbatim in the file "LICENSE" *
+ ********************************************************************************/
+
+/// @brief Memory allocators and interfaces related to managing memory via the
+/// trasport layer
+///
+/// @author Mikolaj Krzewicki, mkrzewic@cern.ch
+
+#include <fairmq/FairMQTransportFactory.h>
+#include <fairmq/MemoryResources.h>
+
+void *fair::mq::ChannelResource::do_allocate(std::size_t bytes, std::size_t /*alignment*/)
+{
+    return setMessage(factory->CreateMessage(bytes));
+};
+

fairmq/MemoryResources.h

@@ -0,0 +1,116 @@
+/********************************************************************************
+ *    Copyright (C) 2018 CERN and copyright holders of ALICE O2 *
+ *    Copyright (C) 2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
+ *                                                                              *
+ *              This software is distributed under the terms of the *
+ *              GNU Lesser General Public Licence (LGPL) version 3, *
+ *                  copied verbatim in the file "LICENSE" *
+ ********************************************************************************/
+
+/// @brief Memory allocators and interfaces related to managing memory via the
+/// trasport layer
+///
+/// @author Mikolaj Krzewicki, mkrzewic@cern.ch
+
+#ifndef FAIR_MQ_MEMORY_RESOURCES_H
+#define FAIR_MQ_MEMORY_RESOURCES_H
+
+#include <fairmq/FairMQMessage.h>
+class FairMQTransportFactory;
+
+#include <boost/container/flat_map.hpp>
+#include <boost/container/pmr/memory_resource.hpp>
+#include <boost/container/pmr/monotonic_buffer_resource.hpp>
+#include <boost/container/pmr/polymorphic_allocator.hpp>
+#include <cstring>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace fair {
+namespace mq {
+
+using byte = unsigned char;
+namespace pmr = boost::container::pmr;
+
+/// All FairMQ related memory resources need to inherit from this interface
+/// class for the
+/// getMessage() api.
+class FairMQMemoryResource : public pmr::memory_resource
+{
+  public:
+    /// return the message containing data associated with the pointer (to start
+    /// of
+    /// buffer), e.g. pointer returned by std::vector::data() return nullptr if
+    /// returning
+    /// a message does not make sense!
+    virtual FairMQMessagePtr getMessage(void *p) = 0;
+    virtual void *setMessage(FairMQMessagePtr) = 0;
+    virtual FairMQTransportFactory *getTransportFactory() noexcept = 0;
+    virtual size_t getNumberOfMessages() const noexcept = 0;
+};
+
+/// This is the allocator that interfaces to FairMQ memory management. All
+/// allocations are
+/// delegated to FairMQ so standard (e.g. STL) containers can construct their
+/// stuff in
+/// memory regions appropriate for the data channel configuration.
+class ChannelResource : public FairMQMemoryResource
+{
+  protected:
+    FairMQTransportFactory *factory{nullptr};
+    // TODO: for now a map to keep track of allocations, something else would
+    // probably be
+    // faster, but for now this does not need to be fast.
+    boost::container::flat_map<void *, FairMQMessagePtr> messageMap;
+
+  public:
+    ChannelResource() = delete;
+
+    ChannelResource(FairMQTransportFactory *_factory)
+        : FairMQMemoryResource()
+        , factory(_factory)
+        , messageMap()
+    {
+        if (!_factory) {
+            throw std::runtime_error("Tried to construct from a nullptr FairMQTransportFactory");
+        }
+    };
+
+    FairMQMessagePtr getMessage(void *p) override
+    {
+        auto mes = std::move(messageMap[p]);
+        messageMap.erase(p);
+        return mes;
+    }
+
+    void *setMessage(FairMQMessagePtr message) override
+    {
+        void *addr = message->GetData();
+        messageMap[addr] = std::move(message);
+        return addr;
+    }
+
+    FairMQTransportFactory *getTransportFactory() noexcept override { return factory; }
+
+    size_t getNumberOfMessages() const noexcept override { return messageMap.size(); }
+
+  protected:
+    void *do_allocate(std::size_t bytes, std::size_t alignment) override;
+    void do_deallocate(void *p, std::size_t /*bytes*/, std::size_t /*alignment*/) override
+    {
+        messageMap.erase(p);
+    };
+
+    bool do_is_equal(const pmr::memory_resource &other) const noexcept override
+    {
+        return this == &other;
+    };
+};
+
+} /* namespace mq */
+} /* namespace fair */
+
+#endif /* FAIR_MQ_MEMORY_RESOURCES_H */

fairmq/PluginServices.h

@@ -186,13 +186,16 @@ class PluginServices
     auto SetProperty(const std::string& key, T val) -> void
     {
         auto currentState = GetCurrentDeviceState();
-        if (currentState == DeviceState::InitializingDevice)
+        if (   (currentState == DeviceState::InitializingDevice)
+            || ((currentState == DeviceState::Idle) && (key == "channel-config")))
         {
             fConfig.SetValue(key, val);
         }
         else
         {
-            throw InvalidStateError{tools::ToString("PluginServices::SetProperty is not supported in device state ", currentState, ". Supported state is ", DeviceState::InitializingDevice, ".")};
+            throw InvalidStateError{
+                tools::ToString("PluginServices::SetProperty is not supported in device state ", currentState, ". ",
+                                "Supported state is ", DeviceState::InitializingDevice, ".")};
         }
     }
     struct InvalidStateError : std::runtime_error { using std::runtime_error::runtime_error; };

fairmq/devices/FairMQBenchmarkSampler.cxx

@@ -18,7 +18,8 @@
 using namespace std;
 
 FairMQBenchmarkSampler::FairMQBenchmarkSampler()
-    : fSameMessage(true)
+    : fMultipart(false)
+    , fNumParts(1)
     , fMsgSize(10000)
     , fMsgRate(0)
     , fNumIterations(0)
@@ -33,8 +34,9 @@ FairMQBenchmarkSampler::~FairMQBenchmarkSampler()
 
 void FairMQBenchmarkSampler::InitTask()
 {
-    fSameMessage = fConfig->GetValue<bool>("same-msg");
-    fMsgSize = fConfig->GetValue<int>("msg-size");
+    fMultipart = fConfig->GetValue<bool>("multipart");
+    fNumParts = fConfig->GetValue<size_t>("num-parts");
+    fMsgSize = fConfig->GetValue<size_t>("msg-size");
     fMsgRate = fConfig->GetValue<float>("msg-rate");
     fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
     fOutChannelName = fConfig->GetValue<string>("out-channel");
@@ -54,12 +56,16 @@ void FairMQBenchmarkSampler::Run()
 
     while (CheckCurrentState(RUNNING))
     {
-        if (fSameMessage)
+        if (fMultipart)
         {
-            FairMQMessagePtr msg(dataOutChannel.NewMessage());
-            msg->Copy(*baseMsg);
+            FairMQParts parts;
 
-            if (dataOutChannel.Send(msg) >= 0)
+            for (size_t i = 0; i < fNumParts; ++i)
+            {
+                parts.AddPart(dataOutChannel.NewMessage(fMsgSize));
+            }
+
+            if (dataOutChannel.Send(parts) >= 0)
             {
                 if (fMaxIterations > 0)
                 {

fairmq/devices/FairMQBenchmarkSampler.h

@@ -26,8 +26,9 @@ class FairMQBenchmarkSampler : public FairMQDevice
     virtual ~FairMQBenchmarkSampler();
 
   protected:
-    bool fSameMessage;
-    int fMsgSize;
+    bool fMultipart;
+    size_t fNumParts;
+    size_t fMsgSize;
     std::atomic<int> fMsgCounter;
     float fMsgRate;
     uint64_t fNumIterations;

fairmq/devices/FairMQMerger.cxx

@@ -20,7 +20,7 @@
 using namespace std;
 
 FairMQMerger::FairMQMerger()
-    : fMultipart(1)
+    : fMultipart(true)
     , fInChannelName("data-in")
     , fOutChannelName("data-out")
 {
@@ -30,6 +30,8 @@ void FairMQMerger::RegisterChannelEndpoints()
 {
     RegisterChannelEndpoint(fInChannelName, 1, 10000);
     RegisterChannelEndpoint(fOutChannelName, 1, 1);
+
+    PrintRegisteredChannels();
 }
 
 FairMQMerger::~FairMQMerger()
@@ -38,7 +40,7 @@ FairMQMerger::~FairMQMerger()
 
 void FairMQMerger::InitTask()
 {
-    fMultipart = fConfig->GetValue<int>("multipart");
+    fMultipart = fConfig->GetValue<bool>("multipart");
     fInChannelName = fConfig->GetValue<string>("in-channel");
     fOutChannelName = fConfig->GetValue<string>("out-channel");
 }
@@ -47,7 +49,7 @@ void FairMQMerger::Run()
 {
     int numInputs = fChannels.at(fInChannelName).size();
 
-    vector<const FairMQChannel*> chans;
+    vector<FairMQChannel*> chans;
 
     for (auto& chan : fChannels.at(fInChannelName))
     {

fairmq/devices/FairMQMerger.h

@@ -26,7 +26,7 @@ class FairMQMerger : public FairMQDevice
     virtual ~FairMQMerger();
 
   protected:
-    int fMultipart;
+    bool fMultipart;
     std::string fInChannelName;
     std::string fOutChannelName;
 

fairmq/devices/FairMQMultiplier.cxx

@@ -14,7 +14,7 @@
 using namespace std;
 
 FairMQMultiplier::FairMQMultiplier()
-    : fMultipart(1)
+    : fMultipart(true)
     , fNumOutputs(0)
     , fInChannelName()
     , fOutChannelNames()
@@ -27,7 +27,7 @@ FairMQMultiplier::~FairMQMultiplier()
 
 void FairMQMultiplier::InitTask()
 {
-    fMultipart = fConfig->GetValue<int>("multipart");
+    fMultipart = fConfig->GetValue<bool>("multipart");
     fInChannelName = fConfig->GetValue<string>("in-channel");
     fOutChannelNames = fConfig->GetValue<vector<string>>("out-channel");
     fNumOutputs = fChannels.at(fOutChannelNames.at(0)).size();

fairmq/devices/FairMQMultiplier.h

@@ -20,7 +20,7 @@ class FairMQMultiplier : public FairMQDevice
     virtual ~FairMQMultiplier();
 
   protected:
-    int fMultipart;
+    bool fMultipart;
     int fNumOutputs;
     std::string fInChannelName;
     std::vector<std::string> fOutChannelNames;

fairmq/devices/FairMQProxy.cxx

@@ -20,7 +20,7 @@
 using namespace std;
 
 FairMQProxy::FairMQProxy()
-    : fMultipart(1)
+    : fMultipart(true)
     , fInChannelName()
     , fOutChannelName()
 {
@@ -32,7 +32,7 @@ FairMQProxy::~FairMQProxy()
 
 void FairMQProxy::InitTask()
 {
-    fMultipart = fConfig->GetValue<int>("multipart");
+    fMultipart = fConfig->GetValue<bool>("multipart");
     fInChannelName = fConfig->GetValue<string>("in-channel");
     fOutChannelName = fConfig->GetValue<string>("out-channel");
 }

fairmq/devices/FairMQProxy.h

@@ -26,7 +26,7 @@ class FairMQProxy : public FairMQDevice
     virtual ~FairMQProxy();
 
   protected:
-    int fMultipart;
+    bool fMultipart;
     std::string fInChannelName;
     std::string fOutChannelName;
 

fairmq/devices/FairMQSink.h

@@ -27,7 +27,8 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
 {
   public:
     FairMQSink()
-        : fMaxIterations(0)
+        : fMultipart(false)
+        , fMaxIterations(0)
         , fNumIterations(0)
         , fInChannelName()
     {}
@@ -36,12 +37,14 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
     {}
 
   protected:
+    bool fMultipart;
     uint64_t fMaxIterations;
     uint64_t fNumIterations;
     std::string fInChannelName;
 
     virtual void InitTask()
     {
+        fMultipart = fConfig->GetValue<bool>("multipart");
         fMaxIterations = fConfig->GetValue<uint64_t>("max-iterations");
         fInChannelName = fConfig->GetValue<std::string>("in-channel");
     }
@@ -56,18 +59,39 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
 
         while (CheckCurrentState(RUNNING))
         {
-            FairMQMessagePtr msg(dataInChannel.NewMessage());
-
-            if (dataInChannel.Receive(msg) >= 0)
+            if (fMultipart)
             {
-                if (fMaxIterations > 0)
+                FairMQParts parts;
+
+                if (dataInChannel.Receive(parts) >= 0)
                 {
-                    if (fNumIterations >= fMaxIterations)
+                    if (fMaxIterations > 0)
                     {
-                        break;
+                        if (fNumIterations >= fMaxIterations)
+                        {
+                            LOG(info) << "Configured maximum number of iterations reached.";
+                            break;
+                        }
                     }
+                    fNumIterations++;
+                }
+            }
+            else
+            {
+                FairMQMessagePtr msg(dataInChannel.NewMessage());
+
+                if (dataInChannel.Receive(msg) >= 0)
+                {
+                    if (fMaxIterations > 0)
+                    {
+                        if (fNumIterations >= fMaxIterations)
+                        {
+                            LOG(info) << "Configured maximum number of iterations reached.";
+                            break;
+                        }
+                    }
+                    fNumIterations++;
                 }
-                fNumIterations++;
             }
         }
 

fairmq/devices/FairMQSplitter.cxx

@@ -20,7 +20,7 @@
 using namespace std;
 
 FairMQSplitter::FairMQSplitter()
-    : fMultipart(1)
+    : fMultipart(true)
     , fNumOutputs(0)
     , fDirection(0)
     , fInChannelName()
@@ -34,7 +34,7 @@ FairMQSplitter::~FairMQSplitter()
 
 void FairMQSplitter::InitTask()
 {
-    fMultipart = fConfig->GetValue<int>("multipart");
+    fMultipart = fConfig->GetValue<bool>("multipart");
     fInChannelName = fConfig->GetValue<string>("in-channel");
     fOutChannelName = fConfig->GetValue<string>("out-channel");
     fNumOutputs = fChannels.at(fOutChannelName).size();

fairmq/devices/FairMQSplitter.h

@@ -26,7 +26,7 @@ class FairMQSplitter : public FairMQDevice
     virtual ~FairMQSplitter();
 
   protected:
-    int fMultipart;
+    bool fMultipart;
     int fNumOutputs;
     int fDirection;
     std::string fInChannelName;

fairmq/nanomsg/FairMQMessageNN.cxx

@@ -24,8 +24,9 @@ using namespace std;
 
 fair::mq::Transport FairMQMessageNN::fTransportType = fair::mq::Transport::NN;
 
-FairMQMessageNN::FairMQMessageNN()
-    : fMessage(nullptr)
+FairMQMessageNN::FairMQMessageNN(FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fMessage(nullptr)
     , fSize(0)
     , fHint(0)
     , fReceiving(false)
@@ -38,8 +39,9 @@ FairMQMessageNN::FairMQMessageNN()
     }
 }
 
-FairMQMessageNN::FairMQMessageNN(const size_t size)
-    : fMessage(nullptr)
+FairMQMessageNN::FairMQMessageNN(const size_t size, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fMessage(nullptr)
     , fSize(0)
     , fHint(0)
     , fReceiving(false)
@@ -59,8 +61,9 @@ FairMQMessageNN::FairMQMessageNN(const size_t size)
  * create FairMQMessage object only with size parameter and fill it with data.
  * possible TODO: make this zero copy (will should then be as efficient as ZeroMQ).
 */
-FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
-    : fMessage(nullptr)
+FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fMessage(nullptr)
     , fSize(0)
     , fHint(0)
     , fReceiving(false)
@@ -86,8 +89,9 @@ FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn*
     }
 }
 
-FairMQMessageNN::FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
-    : fMessage(data)
+FairMQMessageNN::FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fMessage(data)
     , fSize(size)
     , fHint(reinterpret_cast<size_t>(hint))
     , fReceiving(false)

fairmq/nanomsg/FairMQMessageNN.h

@@ -24,15 +24,15 @@
 
 class FairMQSocketNN;
 
-class FairMQMessageNN : public FairMQMessage
+class FairMQMessageNN final : public FairMQMessage
 {
     friend class FairMQSocketNN;
 
   public:
-    FairMQMessageNN();
-    FairMQMessageNN(const size_t size);
-    FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr);
-    FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0);
+    FairMQMessageNN(FairMQTransportFactory* factory = nullptr);
+    FairMQMessageNN(const size_t size, FairMQTransportFactory* factory = nullptr);
+    FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr, FairMQTransportFactory* factory = nullptr);
+    FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, FairMQTransportFactory* factory = nullptr);
 
     FairMQMessageNN(const FairMQMessageNN&) = delete;
     FairMQMessageNN operator=(const FairMQMessageNN&) = delete;

fairmq/nanomsg/FairMQPollerNN.cxx

@@ -19,6 +19,7 @@
 #include <nanomsg/pair.h>
 
 #include "FairMQPollerNN.h"
+#include "FairMQSocketNN.h"
 #include "FairMQLogger.h"
 
 using namespace std;
@@ -33,17 +34,17 @@ FairMQPollerNN::FairMQPollerNN(const vector<FairMQChannel>& channels)
 
     for (int i = 0; i < fNumItems; ++i)
     {
-        fItems[i].fd = channels.at(i).GetSocket().GetSocket(1);
+        fItems[i].fd = static_cast<const FairMQSocketNN*>(&(channels.at(i).GetSocket()))->GetSocket();
 
         int type = 0;
         size_t sz = sizeof(type);
-        nn_getsockopt(channels.at(i).GetSocket().GetSocket(1), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
+        nn_getsockopt(static_cast<const FairMQSocketNN*>(&(channels.at(i).GetSocket()))->GetSocket(), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
 
         SetItemEvents(fItems[i], type);
     }
 }
 
-FairMQPollerNN::FairMQPollerNN(const vector<const FairMQChannel*>& channels)
+FairMQPollerNN::FairMQPollerNN(const vector<FairMQChannel*>& channels)
     : fItems()
     , fNumItems(0)
     , fOffsetMap()
@@ -53,11 +54,11 @@ FairMQPollerNN::FairMQPollerNN(const vector<const FairMQChannel*>& channels)
 
     for (int i = 0; i < fNumItems; ++i)
     {
-        fItems[i].fd = channels.at(i)->GetSocket().GetSocket(1);
+        fItems[i].fd = static_cast<const FairMQSocketNN*>(&(channels.at(i)->GetSocket()))->GetSocket();
 
         int type = 0;
         size_t sz = sizeof(type);
-        nn_getsockopt(channels.at(i)->GetSocket().GetSocket(1), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
+        nn_getsockopt(static_cast<const FairMQSocketNN*>(&(channels.at(i)->GetSocket()))->GetSocket(), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
 
         SetItemEvents(fItems[i], type);
     }
@@ -87,11 +88,11 @@ FairMQPollerNN::FairMQPollerNN(const unordered_map<string, vector<FairMQChannel>
             for (unsigned int i = 0; i < channelsMap.at(channel).size(); ++i)
             {
                 index = fOffsetMap[channel] + i;
-                fItems[index].fd = channelsMap.at(channel).at(i).GetSocket().GetSocket(1);
+                fItems[index].fd = static_cast<const FairMQSocketNN*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket();
 
                 int type = 0;
                 size_t sz = sizeof(type);
-                nn_getsockopt(channelsMap.at(channel).at(i).GetSocket().GetSocket(1), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
+                nn_getsockopt(static_cast<const FairMQSocketNN*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket(), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
 
                 SetItemEvents(fItems[index], type);
             }
@@ -105,27 +106,6 @@ FairMQPollerNN::FairMQPollerNN(const unordered_map<string, vector<FairMQChannel>
     }
 }
 
-FairMQPollerNN::FairMQPollerNN(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket)
-    : fItems()
-    , fNumItems(2)
-    , fOffsetMap()
-{
-    fItems = new nn_pollfd[fNumItems];
-
-    fItems[0].fd = cmdSocket.GetSocket(1);
-    fItems[0].events = NN_POLLIN;
-    fItems[0].revents = 0;
-
-    fItems[1].fd = dataSocket.GetSocket(1);
-    fItems[1].revents = 0;
-
-    int type = 0;
-    size_t sz = sizeof(type);
-    nn_getsockopt(dataSocket.GetSocket(1), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
-
-    SetItemEvents(fItems[1], type);
-}
-
 void FairMQPollerNN::SetItemEvents(nn_pollfd& item, const int type)
 {
     if (type == NN_REQ || type == NN_REP || type == NN_PAIR)

fairmq/nanomsg/FairMQPollerNN.h

@@ -26,14 +26,14 @@
 class FairMQChannel;
 struct nn_pollfd;
 
-class FairMQPollerNN : public FairMQPoller
+class FairMQPollerNN final : public FairMQPoller
 {
     friend class FairMQChannel;
     friend class FairMQTransportFactoryNN;
 
   public:
     FairMQPollerNN(const std::vector<FairMQChannel>& channels);
-    FairMQPollerNN(const std::vector<const FairMQChannel*>& channels);
+    FairMQPollerNN(const std::vector<FairMQChannel*>& channels);
     FairMQPollerNN(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList);
 
     FairMQPollerNN(const FairMQPollerNN&) = delete;
@@ -41,21 +41,19 @@ class FairMQPollerNN : public FairMQPoller
 
     void SetItemEvents(nn_pollfd& item, const int type);
 
-    virtual void Poll(const int timeout);
-    virtual bool CheckInput(const int index);
-    virtual bool CheckOutput(const int index);
-    virtual bool CheckInput(const std::string& channelKey, const int index);
-    virtual bool CheckOutput(const std::string& channelKey, const int index);
+    void Poll(const int timeout) override;
+    bool CheckInput(const int index) override;
+    bool CheckOutput(const int index) override;
+    bool CheckInput(const std::string& channelKey, const int index) override;
+    bool CheckOutput(const std::string& channelKey, const int index) override;
 
-    virtual ~FairMQPollerNN();
+    ~FairMQPollerNN() override;
 
   private:
-    FairMQPollerNN(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket);
-
     nn_pollfd* fItems;
     int fNumItems;
 
     std::unordered_map<std::string, int> fOffsetMap;
 };
 
-#endif /* FAIRMQPOLLERNN_H_ */
+#endif /* FAIRMQPOLLERNN_H_ */

fairmq/nanomsg/FairMQSocketNN.cxx

@@ -16,6 +16,7 @@
 #include "FairMQMessageNN.h"
 #include "FairMQLogger.h"
 #include "FairMQUnmanagedRegionNN.h"
+#include <fairmq/Tools.h>
 
 #include <nanomsg/nn.h>
 #include <nanomsg/pipeline.h>
@@ -27,6 +28,7 @@
 #include <msgpack.hpp>
 
 using namespace std;
+using namespace fair::mq;
 
 atomic<bool> FairMQSocketNN::fInterrupted(false);
 
@@ -39,6 +41,7 @@ FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const str
     , fMessagesRx(0)
     , fSndTimeout(100)
     , fRcvTimeout(100)
+    , fLinger(500)
 {
     if (type == "router" || type == "dealer")
     {
@@ -116,18 +119,13 @@ void FairMQSocketNN::Connect(const string& address)
     }
 }
 
-int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int timeout) { return SendImpl(msg, 0, timeout); }
-int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int timeout) { return ReceiveImpl(msg, 0, timeout); }
-int64_t FairMQSocketNN::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return SendImpl(msgVec, 0, timeout); }
-int64_t FairMQSocketNN::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return ReceiveImpl(msgVec, 0, timeout); }
-
-int FairMQSocketNN::TrySend(FairMQMessagePtr& msg) { return SendImpl(msg, NN_DONTWAIT, 0); }
-int FairMQSocketNN::TryReceive(FairMQMessagePtr& msg) { return ReceiveImpl(msg, NN_DONTWAIT, 0); }
-int64_t FairMQSocketNN::TrySend(vector<unique_ptr<FairMQMessage>>& msgVec) { return SendImpl(msgVec, NN_DONTWAIT, 0); }
-int64_t FairMQSocketNN::TryReceive(vector<unique_ptr<FairMQMessage>>& msgVec) { return ReceiveImpl(msgVec, NN_DONTWAIT, 0); }
-
-int FairMQSocketNN::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
+int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = NN_DONTWAIT;
+    }
     int nbytes = -1;
     int elapsed = 0;
 
@@ -155,15 +153,11 @@ int FairMQSocketNN::SendImpl(FairMQMessagePtr& msg, const int flags, const int t
 
             return nbytes;
         }
-#if NN_VERSION_CURRENT>2 // backwards-compatibility with nanomsg version<=0.6
         else if (nn_errno() == ETIMEDOUT)
-#else
-        else if (nn_errno() == EAGAIN)
-#endif
         {
             if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fSndTimeout;
                     if (elapsed >= timeout)
@@ -195,8 +189,13 @@ int FairMQSocketNN::SendImpl(FairMQMessagePtr& msg, const int flags, const int t
     }
 }
 
-int FairMQSocketNN::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
+int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = NN_DONTWAIT;
+    }
     int elapsed = 0;
 
     FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get());
@@ -213,15 +212,11 @@ int FairMQSocketNN::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const in
             msgPtr->fReceiving = true;
             return nbytes;
         }
-#if NN_VERSION_CURRENT>2 // backwards-compatibility with nanomsg version<=0.6
         else if (nn_errno() == ETIMEDOUT)
-#else
-        else if (nn_errno() == EAGAIN)
-#endif
         {
             if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fRcvTimeout;
                     if (elapsed >= timeout)
@@ -253,8 +248,13 @@ int FairMQSocketNN::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const in
     }
 }
 
-int64_t FairMQSocketNN::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
+int64_t FairMQSocketNN::Send(vector<FairMQMessagePtr>& msgVec, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = NN_DONTWAIT;
+    }
     const unsigned int vecSize = msgVec.size();
     int elapsed = 0;
 
@@ -287,15 +287,11 @@ int64_t FairMQSocketNN::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fla
             ++fMessagesTx;
             return nbytes;
         }
-#if NN_VERSION_CURRENT>2 // backwards-compatibility with nanomsg version<=0.6
         else if (nn_errno() == ETIMEDOUT)
-#else
-        else if (nn_errno() == EAGAIN)
-#endif
         {
             if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fSndTimeout;
                     if (elapsed >= timeout)
@@ -327,8 +323,13 @@ int64_t FairMQSocketNN::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fla
     }
 }
 
-int64_t FairMQSocketNN::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
+int64_t FairMQSocketNN::Receive(vector<FairMQMessagePtr>& msgVec, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = NN_DONTWAIT;
+    }
     // Warn if the vector is filled before Receive() and empty it.
     // if (msgVec.size() > 0)
     // {
@@ -374,15 +375,11 @@ int64_t FairMQSocketNN::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int
             nn_freemsg(ptr);
             return nbytes;
         }
-#if NN_VERSION_CURRENT>2 // backwards-compatibility with nanomsg version<=0.6
         else if (nn_errno() == ETIMEDOUT)
-#else
-        else if (nn_errno() == EAGAIN)
-#endif
         {
             if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fRcvTimeout;
                     if (elapsed >= timeout)
@@ -429,12 +426,7 @@ void FairMQSocketNN::Resume()
     fInterrupted = false;
 }
 
-void* FairMQSocketNN::GetSocket() const
-{
-    return nullptr; // dummy method to comply with the interface. functionality not possible in zeromq.
-}
-
-int FairMQSocketNN::GetSocket(int /*nothing*/) const
+int FairMQSocketNN::GetSocket() const
 {
     return fSocket;
 }
@@ -446,7 +438,7 @@ void FairMQSocketNN::SetOption(const string& option, const void* value, size_t v
         int val = *(static_cast<int*>(const_cast<void*>(value)));
         if (val <= 0)
         {
-            LOG(warn) << "value for sndKernelSize/rcvKernelSize should be greater than 0, using defaults (128kB).";
+            LOG(warn) << "value for sndKernelSize/rcvKernelSize should be greater than 0, leaving unchanged.";
             return;
         }
     }
@@ -456,6 +448,12 @@ void FairMQSocketNN::SetOption(const string& option, const void* value, size_t v
         return;
     }
 
+    if (option == "linger")
+    {
+        fLinger = *static_cast<int*>(const_cast<void*>(value));
+        return;
+    }
+
     int rc = nn_setsockopt(fSocket, NN_SOL_SOCKET, GetConstant(option), value, valueSize);
     if (rc < 0)
     {
@@ -465,6 +463,19 @@ void FairMQSocketNN::SetOption(const string& option, const void* value, size_t v
 
 void FairMQSocketNN::GetOption(const string& option, void* value, size_t* valueSize)
 {
+    if (option == "linger")
+    {
+        *static_cast<int*>(value) = fLinger;
+        return;
+    }
+
+    if (option == "snd-hwm" || option == "rcv-hwm")
+    {
+        *static_cast<int*>(value) = -1;
+        return;
+    }
+
+
     int rc = nn_getsockopt(fSocket, NN_SOL_SOCKET, GetConstant(option), value, valueSize);
     if (rc < 0)
     {
@@ -472,6 +483,73 @@ void FairMQSocketNN::GetOption(const string& option, void* value, size_t* valueS
     }
 }
 
+void FairMQSocketNN::SetLinger(const int value)
+{
+    fLinger = value;
+}
+
+int FairMQSocketNN::GetLinger() const
+{
+    return fLinger;
+}
+
+void FairMQSocketNN::SetSndBufSize(const int /* value */)
+{
+    // not used in nanomsg
+}
+
+int FairMQSocketNN::GetSndBufSize() const
+{
+    // not used in nanomsg
+    return -1;
+}
+
+void FairMQSocketNN::SetRcvBufSize(const int /* value */)
+{
+    // not used in nanomsg
+}
+
+int FairMQSocketNN::GetRcvBufSize() const
+{
+    // not used in nanomsg
+    return -1;
+}
+
+void FairMQSocketNN::SetSndKernelSize(const int value)
+{
+    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting NN_SNDBUF, reason: ", nn_strerror(errno)));
+    }
+}
+
+int FairMQSocketNN::GetSndKernelSize() const
+{
+    int value = 0;
+    size_t valueSize;
+    if (nn_getsockopt(fSocket, NN_SOL_SOCKET, NN_SNDBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting NN_SNDBUF, reason: ", nn_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketNN::SetRcvKernelSize(const int value)
+{
+    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting NN_RCVBUF, reason: ", nn_strerror(errno)));
+    }
+}
+
+int FairMQSocketNN::GetRcvKernelSize() const
+{
+    int value = 0;
+    size_t valueSize;
+    if (nn_getsockopt(fSocket, NN_SOL_SOCKET, NN_RCVBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting NN_RCVBUF, reason: ", nn_strerror(errno)));
+    }
+    return value;
+}
+
+
 unsigned long FairMQSocketNN::GetBytesTx() const
 {
     return fBytesTx;
@@ -492,40 +570,6 @@ unsigned long FairMQSocketNN::GetMessagesRx() const
     return fMessagesRx;
 }
 
-bool FairMQSocketNN::SetSendTimeout(const int timeout, const string& /*address*/, const string& /*method*/)
-{
-    fSndTimeout = timeout;
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-    {
-        LOG(error) << "Failed setting option 'send timeout' on socket " << fId << ", reason: " << nn_strerror(errno);
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketNN::GetSendTimeout() const
-{
-    return fSndTimeout;
-}
-
-bool FairMQSocketNN::SetReceiveTimeout(const int timeout, const string& /*address*/, const string& /*method*/)
-{
-    fRcvTimeout = timeout;
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-    {
-        LOG(error) << "Failed setting option 'receive timeout' on socket " << fId << ", reason: " << nn_strerror(errno);
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketNN::GetReceiveTimeout() const
-{
-    return fRcvTimeout;
-}
-
 int FairMQSocketNN::GetConstant(const string& constant)
 {
     if (constant == "")

fairmq/nanomsg/FairMQSocketNN.h

@@ -15,7 +15,7 @@
 #include "FairMQSocket.h"
 #include "FairMQMessage.h"
 
-class FairMQSocketNN : public FairMQSocket
+class FairMQSocketNN final : public FairMQSocket
 {
   public:
     FairMQSocketNN(const std::string& type, const std::string& name, const std::string& id = "");
@@ -27,18 +27,12 @@ class FairMQSocketNN : public FairMQSocket
     bool Bind(const std::string& address) override;
     void Connect(const std::string& address) override;
 
-    int Send(FairMQMessagePtr& msg, const int timeout = 0) override;
-    int Receive(FairMQMessagePtr& msg, const int timeout = 0) override;
-    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
-    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
+    int Send(FairMQMessagePtr& msg, const int timeout = -1) override;
+    int Receive(FairMQMessagePtr& msg, const int timeout = -1) override;
+    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
+    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
 
-    int TrySend(FairMQMessagePtr& msg) override;
-    int TryReceive(FairMQMessagePtr& msg) override;
-    int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
-    int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
-
-    void* GetSocket() const override;
-    int GetSocket(int nothing) const override;
+    int GetSocket() const;
 
     void Close() override;
 
@@ -48,16 +42,22 @@ class FairMQSocketNN : public FairMQSocket
     void SetOption(const std::string& option, const void* value, size_t valueSize) override;
     void GetOption(const std::string& option, void* value, size_t* valueSize) override;
 
+    void SetLinger(const int value) override;
+    int GetLinger() const override;
+    void SetSndBufSize(const int value) override;
+    int GetSndBufSize() const override;
+    void SetRcvBufSize(const int value) override;
+    int GetRcvBufSize() const override;
+    void SetSndKernelSize(const int value) override;
+    int GetSndKernelSize() const override;
+    void SetRcvKernelSize(const int value) override;
+    int GetRcvKernelSize() const override;
+
     unsigned long GetBytesTx() const override;
     unsigned long GetBytesRx() const override;
     unsigned long GetMessagesTx() const override;
     unsigned long GetMessagesRx() const override;
 
-    bool SetSendTimeout(const int timeout, const std::string& address, const std::string& method) override;
-    int GetSendTimeout() const override;
-    bool SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method) override;
-    int GetReceiveTimeout() const override;
-
     static int GetConstant(const std::string& constant);
 
     ~FairMQSocketNN() override;
@@ -74,11 +74,7 @@ class FairMQSocketNN : public FairMQSocket
 
     int fSndTimeout;
     int fRcvTimeout;
-
-    int SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
-    int ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
-    int64_t SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
-    int64_t ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
+    int fLinger;
 };
 
 #endif /* FAIRMQSOCKETNN_H_ */

fairmq/nanomsg/FairMQTransportFactoryNN.cxx

@@ -9,6 +9,9 @@
 #include "FairMQTransportFactoryNN.h"
 
 #include <nanomsg/nn.h>
+#include <algorithm>
+#include <thread>
+#include <chrono>
 
 using namespace std;
 
@@ -20,29 +23,31 @@ FairMQTransportFactoryNN::FairMQTransportFactoryNN(const string& id, const FairM
     LOG(debug) << "Transport: Using nanomsg library";
 }
 
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage() const
+FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage()
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN());
+    return unique_ptr<FairMQMessage>(new FairMQMessageNN(this));
 }
 
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(const size_t size) const
+FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(const size_t size)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(size));
+    return unique_ptr<FairMQMessage>(new FairMQMessageNN(size, this));
 }
 
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint) const
+FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(data, size, ffn, hint));
+    return unique_ptr<FairMQMessage>(new FairMQMessageNN(data, size, ffn, hint, this));
 }
 
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint) const
+FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(region, data, size, hint));
+    return unique_ptr<FairMQMessage>(new FairMQMessageNN(region, data, size, hint, this));
 }
 
 FairMQSocketPtr FairMQTransportFactoryNN::CreateSocket(const string& type, const string& name) const
 {
-    return unique_ptr<FairMQSocket>(new FairMQSocketNN(type, name, GetId()));
+    unique_ptr<FairMQSocket> socket(new FairMQSocketNN(type, name, GetId()));
+    fSockets.push_back(socket.get());
+    return socket;
 }
 
 FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const vector<FairMQChannel>& channels) const
@@ -50,7 +55,7 @@ FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const vector<FairMQChanne
     return unique_ptr<FairMQPoller>(new FairMQPollerNN(channels));
 }
 
-FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const std::vector<const FairMQChannel*>& channels) const
+FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const std::vector<FairMQChannel*>& channels) const
 {
     return unique_ptr<FairMQPoller>(new FairMQPollerNN(channels));
 }
@@ -60,11 +65,6 @@ FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const unordered_map<strin
     return unique_ptr<FairMQPoller>(new FairMQPollerNN(channelsMap, channelList));
 }
 
-FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const
-{
-    return unique_ptr<FairMQPoller>(new FairMQPollerNN(cmdSocket, dataSocket));
-}
-
 FairMQUnmanagedRegionPtr FairMQTransportFactoryNN::CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const
 {
     return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionNN(size, callback));
@@ -75,6 +75,17 @@ fair::mq::Transport FairMQTransportFactoryNN::GetType() const
     return fTransportType;
 }
 
+void FairMQTransportFactoryNN::Reset()
+{
+    auto it = max_element(fSockets.begin(), fSockets.end(), [](FairMQSocket* s1, FairMQSocket* s2) {
+        return static_cast<FairMQSocketNN*>(s1)->GetLinger() < static_cast<FairMQSocketNN*>(s2)->GetLinger();
+    });
+    if (it != fSockets.end()) {
+        this_thread::sleep_for(chrono::milliseconds(static_cast<FairMQSocketNN*>(*it)->GetLinger()));
+    }
+    fSockets.clear();
+}
+
 FairMQTransportFactoryNN::~FairMQTransportFactoryNN()
 {
     // nn_term();

fairmq/nanomsg/FairMQTransportFactoryNN.h

@@ -19,23 +19,22 @@
 #include <vector>
 #include <string>
 
-class FairMQTransportFactoryNN : public FairMQTransportFactory
+class FairMQTransportFactoryNN final : public FairMQTransportFactory
 {
   public:
     FairMQTransportFactoryNN(const std::string& id = "", const FairMQProgOptions* config = nullptr);
     ~FairMQTransportFactoryNN() override;
 
-    FairMQMessagePtr CreateMessage() const override;
-    FairMQMessagePtr CreateMessage(const size_t size) const override;
-    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const override;
-    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) const override;
+    FairMQMessagePtr CreateMessage() override;
+    FairMQMessagePtr CreateMessage(const size_t size) override;
+    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override;
+    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override;
 
     FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) const override;
 
     FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override;
-    FairMQPollerPtr CreatePoller(const std::vector<const FairMQChannel*>& channels) const override;
+    FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override;
     FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override;
-    FairMQPollerPtr CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const override;
 
     FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const override;
 
@@ -43,9 +42,11 @@ class FairMQTransportFactoryNN : public FairMQTransportFactory
 
     void Interrupt() override { FairMQSocketNN::Interrupt(); }
     void Resume() override { FairMQSocketNN::Resume(); }
+    void Reset() override;
 
   private:
     static fair::mq::Transport fTransportType;
+    mutable std::vector<FairMQSocket*> fSockets;
 };
 
 #endif /* FAIRMQTRANSPORTFACTORYNN_H_ */

fairmq/nanomsg/FairMQUnmanagedRegionNN.h

@@ -13,7 +13,7 @@
 
 #include <cstddef> // size_t
 
-class FairMQUnmanagedRegionNN : public FairMQUnmanagedRegion
+class FairMQUnmanagedRegionNN final : public FairMQUnmanagedRegion
 {
     friend class FairMQSocketNN;
 

fairmq/ofi/Message.h

@@ -30,7 +30,7 @@ namespace ofi
  *
  * @todo TODO insert long description
  */
-class Message : public fair::mq::Message
+class Message final : public fair::mq::Message
 {
   public:
     Message();

fairmq/ofi/Poller.cxx

@@ -7,6 +7,7 @@
  ********************************************************************************/
 
 #include <fairmq/ofi/Poller.h>
+#include <fairmq/ofi/Socket.h>
 #include <fairmq/Tools.h>
 #include <FairMQLogger.h>
 
@@ -27,13 +28,13 @@ Poller::Poller(const vector<FairMQChannel>& channels)
     fItems = new zmq_pollitem_t[fNumItems];
 
     for (int i = 0; i < fNumItems; ++i) {
-        fItems[i].socket = channels.at(i).GetSocket().GetSocket();
+        fItems[i].socket = static_cast<const Socket*>(&(channels.at(i).GetSocket()))->GetSocket();
         fItems[i].fd = 0;
         fItems[i].revents = 0;
 
         int type = 0;
         size_t size = sizeof(type);
-        zmq_getsockopt(channels.at(i).GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+        zmq_getsockopt(static_cast<const Socket*>(&(channels.at(i).GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
         SetItemEvents(fItems[i], type);
     }
@@ -45,13 +46,13 @@ Poller::Poller(const vector<const FairMQChannel*>& channels)
     fItems = new zmq_pollitem_t[fNumItems];
 
     for (int i = 0; i < fNumItems; ++i) {
-        fItems[i].socket = channels.at(i)->GetSocket().GetSocket();
+        fItems[i].socket = static_cast<const Socket*>(&(channels.at(i)->GetSocket()))->GetSocket();
         fItems[i].fd = 0;
         fItems[i].revents = 0;
 
         int type = 0;
         size_t size = sizeof(type);
-        zmq_getsockopt(channels.at(i)->GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+        zmq_getsockopt(static_cast<const Socket*>(&(channels.at(i)->GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
         SetItemEvents(fItems[i], type);
     }
@@ -75,13 +76,13 @@ Poller::Poller(const unordered_map<string, vector<FairMQChannel>>& channelsMap,
             for (unsigned int i = 0; i < channelsMap.at(channel).size(); ++i) {
                 index = fOffsetMap[channel] + i;
 
-                fItems[index].socket = channelsMap.at(channel).at(i).GetSocket().GetSocket();
+                fItems[index].socket = static_cast<const Socket*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket();
                 fItems[index].fd = 0;
                 fItems[index].revents = 0;
 
                 int type = 0;
                 size_t size = sizeof(type);
-                zmq_getsockopt(channelsMap.at(channel).at(i).GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+                zmq_getsockopt(static_cast<const Socket*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
                 SetItemEvents(fItems[index], type);
             }
@@ -93,27 +94,6 @@ Poller::Poller(const unordered_map<string, vector<FairMQChannel>>& channelsMap,
     }
 }
 
-Poller::Poller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket)
-    : fNumItems{2}
-{
-    fItems = new zmq_pollitem_t[fNumItems];
-
-    fItems[0].socket = cmdSocket.GetSocket();
-    fItems[0].fd = 0;
-    fItems[0].events = ZMQ_POLLIN;
-    fItems[0].revents = 0;
-
-    fItems[1].socket = dataSocket.GetSocket();
-    fItems[1].fd = 0;
-    fItems[1].revents = 0;
-
-    int type = 0;
-    size_t size = sizeof(type);
-    zmq_getsockopt(dataSocket.GetSocket(), ZMQ_TYPE, &type, &size);
-
-    SetItemEvents(fItems[1], type);
-}
-
 auto Poller::SetItemEvents(zmq_pollitem_t& item, const int type) -> void
 {
     if (type == ZMQ_PAIR) {

fairmq/ofi/Poller.h

@@ -33,7 +33,7 @@ class TransportFactory;
  *
  * @todo TODO insert long description
  */
-class Poller : public FairMQPoller
+class Poller final : public FairMQPoller
 {
     friend class FairMQChannel;
     friend class TransportFactory;
@@ -57,8 +57,6 @@ class Poller : public FairMQPoller
     ~Poller() override;
 
   private:
-    Poller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket);
-
     zmq_pollitem_t* fItems;
     int fNumItems;
 

fairmq/ofi/Socket.cxx

@@ -619,114 +619,82 @@ auto Socket::GetOption(const string& option, void* value, size_t* valueSize) ->
     }
 }
 
-auto Socket::SetSendTimeout(const int timeout, const string& address, const string& method) -> bool
+int Socket::GetLinger() const
 {
-    throw SocketError{"Not yet implemented."};
-    // fSndTimeout = timeout;
-    // if (method == "bind")
-    // {
-    //     if (zmq_unbind(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-    //     {
-    //         LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_bind(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed binding socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    // }
-    // else if (method == "connect")
-    // {
-    //     if (zmq_disconnect(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-    //     {
-    //         LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_connect(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    // }
-    // else
-    // {
-    //     LOG(error) << "timeout failed - unknown method provided!";
-    //     return false;
-    // }
-    //
-    // return true;
+    int value = 0;
+    size_t valueSize;
+    if (zmq_getsockopt(fControlSocket, ZMQ_LINGER, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_LINGER, reason: ", zmq_strerror(errno)));
+    }
+    return value;
 }
 
-auto Socket::GetSendTimeout() const -> int
+void Socket::SetSndBufSize(const int value)
 {
-    throw SocketError{"Not yet implemented."};
-    // return fSndTimeout;
+    if (zmq_setsockopt(fControlSocket, ZMQ_SNDHWM, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_SNDHWM, reason: ", zmq_strerror(errno)));
+    }
 }
 
-auto Socket::SetReceiveTimeout(const int timeout, const string& address, const string& method) -> bool
+int Socket::GetSndBufSize() const
 {
-    throw SocketError{"Not yet implemented."};
-    // fRcvTimeout = timeout;
-    // if (method == "bind")
-    // {
-    //     if (zmq_unbind(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-    //     {
-    //         LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_bind(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed binding socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    // }
-    // else if (method == "connect")
-    // {
-    //     if (zmq_disconnect(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-    //     {
-    //         LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    //     if (zmq_connect(fSocket, address.c_str()) != 0)
-    //     {
-    //         LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-    //         return false;
-    //     }
-    // }
-    // else
-    // {
-    //     LOG(error) << "timeout failed - unknown method provided!";
-    //     return false;
-    // }
-    //
-    // return true;
+    int value = 0;
+    size_t valueSize;
+    if (zmq_getsockopt(fControlSocket, ZMQ_SNDHWM, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDHWM, reason: ", zmq_strerror(errno)));
+    }
+    return value;
 }
 
-auto Socket::GetReceiveTimeout() const -> int
+void Socket::SetRcvBufSize(const int value)
 {
-    throw SocketError{"Not yet implemented."};
-    // return fRcvTimeout;
+    if (zmq_setsockopt(fControlSocket, ZMQ_RCVHWM, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_RCVHWM, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int Socket::GetRcvBufSize() const
+{
+    int value = 0;
+    size_t valueSize;
+    if (zmq_getsockopt(fControlSocket, ZMQ_RCVHWM, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVHWM, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void Socket::SetSndKernelSize(const int value)
+{
+    if (zmq_setsockopt(fControlSocket, ZMQ_SNDBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDBUF, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int Socket::GetSndKernelSize() const
+{
+    int value = 0;
+    size_t valueSize;
+    if (zmq_getsockopt(fControlSocket, ZMQ_SNDBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDBUF, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void Socket::SetRcvKernelSize(const int value)
+{
+    if (zmq_setsockopt(fControlSocket, ZMQ_RCVBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVBUF, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int Socket::GetRcvKernelSize() const
+{
+    int value = 0;
+    size_t valueSize;
+    if (zmq_getsockopt(fControlSocket, ZMQ_RCVBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVBUF, reason: ", zmq_strerror(errno)));
+    }
+    return value;
 }
 
 auto Socket::GetConstant(const string& constant) -> int

fairmq/ofi/Socket.h

@@ -32,7 +32,7 @@ namespace ofi
  *
  * @todo TODO insert long description
  */
-class Socket : public fair::mq::Socket
+class Socket final : public fair::mq::Socket
 {
   public:
     Socket(Context& factory, const std::string& type, const std::string& name, const std::string& id = "");
@@ -54,8 +54,18 @@ class Socket : public fair::mq::Socket
     auto TrySend(std::vector<MessagePtr>& msgVec) -> int64_t override;
     auto TryReceive(std::vector<MessagePtr>& msgVec) -> int64_t override;
 
-    auto GetSocket() const -> void* override { return fControlSocket; }
-    auto GetSocket(int nothing) const -> int override { return -1; }
+    auto GetSocket() const -> void* { return fControlSocket; }
+
+    void SetLinger(const int value) override;
+    int GetLinger() const override;
+    void SetSndBufSize(const int value) override;
+    int GetSndBufSize() const override;
+    void SetRcvBufSize(const int value) override;
+    int GetRcvBufSize() const override;
+    void SetSndKernelSize(const int value) override;
+    int GetSndKernelSize() const override;
+    void SetRcvKernelSize(const int value) override;
+    int GetRcvKernelSize() const override;
 
     auto Close() -> void override;
 
@@ -67,11 +77,6 @@ class Socket : public fair::mq::Socket
     auto GetMessagesTx() const -> unsigned long override { return fMessagesTx; }
     auto GetMessagesRx() const -> unsigned long override { return fMessagesRx; }
 
-    auto SetSendTimeout(const int timeout, const std::string& address, const std::string& method) -> bool override;
-    auto GetSendTimeout() const -> int override;
-    auto SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method) -> bool override;
-    auto GetReceiveTimeout() const -> int override;
-
     static auto GetConstant(const std::string& constant) -> int;
 
     ~Socket() override;

fairmq/ofi/TransportFactory.cxx

@@ -76,11 +76,6 @@ auto TransportFactory::CreatePoller(const unordered_map<string, vector<FairMQCha
     return PollerPtr{new Poller(channelsMap, channelList)};
 }
 
-auto TransportFactory::CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const -> PollerPtr
-{
-    return PollerPtr{new Poller(cmdSocket, dataSocket)};
-}
-
 auto TransportFactory::CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const -> UnmanagedRegionPtr
 {
     throw runtime_error{"Not yet implemented UMR."};

fairmq/ofi/TransportFactory.h

@@ -26,7 +26,7 @@ namespace ofi
  *
  * @todo TODO insert long description
  */
-class TransportFactory : public FairMQTransportFactory
+class TransportFactory final : public FairMQTransportFactory
 {
   public:
     TransportFactory(const std::string& id = "", const FairMQProgOptions* config = nullptr);
@@ -43,7 +43,6 @@ class TransportFactory : public FairMQTransportFactory
     auto CreatePoller(const std::vector<FairMQChannel>& channels) const -> PollerPtr override;
     auto CreatePoller(const std::vector<const FairMQChannel*>& channels) const -> PollerPtr override;
     auto CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const -> PollerPtr override;
-    auto CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const -> PollerPtr override;
 
     auto CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr) const -> UnmanagedRegionPtr override;
 
@@ -51,6 +50,7 @@ class TransportFactory : public FairMQTransportFactory
 
     void Interrupt() override {}
     void Resume() override {}
+    void Reset() override {}
 
   private:
     mutable Context fContext;

fairmq/options/FairMQParser.cxx

@@ -153,6 +153,7 @@ void ChannelParser(const boost::property_tree::ptree& tree, FairMQChannelMap& ch
                 commonChannel.UpdateRcvBufSize(q.second.get<int>("rcvBufSize", commonChannel.GetRcvBufSize()));
                 commonChannel.UpdateSndKernelSize(q.second.get<int>("sndKernelSize", commonChannel.GetSndKernelSize()));
                 commonChannel.UpdateRcvKernelSize(q.second.get<int>("rcvKernelSize", commonChannel.GetRcvKernelSize()));
+                commonChannel.UpdateLinger(q.second.get<int>("linger", commonChannel.GetLinger()));
                 commonChannel.UpdateRateLogging(q.second.get<int>("rateLogging", commonChannel.GetRateLogging()));
 
                 // temporary FairMQChannel container
@@ -172,6 +173,7 @@ void ChannelParser(const boost::property_tree::ptree& tree, FairMQChannelMap& ch
                     LOG(debug) << "\trcvBufSize    = " << commonChannel.GetRcvBufSize();
                     LOG(debug) << "\tsndKernelSize = " << commonChannel.GetSndKernelSize();
                     LOG(debug) << "\trcvKernelSize = " << commonChannel.GetRcvKernelSize();
+                    LOG(debug) << "\tlinger        = " << commonChannel.GetLinger();
                     LOG(debug) << "\trateLogging   = " << commonChannel.GetRateLogging();
 
                     for (int i = 0; i < numSockets; ++i)
@@ -214,6 +216,7 @@ void SocketParser(const boost::property_tree::ptree& tree, vector<FairMQChannel>
                 channel.UpdateRcvBufSize(q.second.get<int>("rcvBufSize", channel.GetRcvBufSize()));
                 channel.UpdateSndKernelSize(q.second.get<int>("sndKernelSize", channel.GetSndKernelSize()));
                 channel.UpdateRcvKernelSize(q.second.get<int>("rcvKernelSize", channel.GetRcvKernelSize()));
+                channel.UpdateLinger(q.second.get<int>("linger", channel.GetLinger()));
                 channel.UpdateRateLogging(q.second.get<int>("rateLogging", channel.GetRateLogging()));
 
                 LOG(debug) << "" << channelName << "[" << socketCounter << "]:";
@@ -225,6 +228,7 @@ void SocketParser(const boost::property_tree::ptree& tree, vector<FairMQChannel>
                 LOG(debug) << "\trcvBufSize    = " << channel.GetRcvBufSize();
                 LOG(debug) << "\tsndKernelSize = " << channel.GetSndKernelSize();
                 LOG(debug) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
+                LOG(debug) << "\tlinger        = " << channel.GetLinger();
                 LOG(debug) << "\trateLogging   = " << channel.GetRateLogging();
 
                 channelList.push_back(channel);
@@ -253,6 +257,7 @@ void SocketParser(const boost::property_tree::ptree& tree, vector<FairMQChannel>
         LOG(debug) << "\trcvBufSize    = " << channel.GetRcvBufSize();
         LOG(debug) << "\tsndKernelSize = " << channel.GetSndKernelSize();
         LOG(debug) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
+        LOG(debug) << "\tlinger        = " << channel.GetLinger();
         LOG(debug) << "\trateLogging   = " << channel.GetRateLogging();
 
         channelList.push_back(channel);

fairmq/options/FairMQProgOptions.cxx

@@ -162,7 +162,7 @@ int FairMQProgOptions::ParseAll(const int argc, char const* const* argv, bool al
         else if (fVarMap.count("channel-config"))
         {
             LOG(debug) << "channel-config: Parsing channel configuration";
-            UpdateChannelMap(parser::SUBOPT().UserParser(fVarMap.at("channel-config").as<vector<string>>(), idForParser));
+            ParseChannelsFromCmdLine();
         }
         else
         {
@@ -185,6 +185,23 @@ int FairMQProgOptions::ParseAll(const int argc, char const* const* argv, bool al
     return 0;
 }
 
+void FairMQProgOptions::ParseChannelsFromCmdLine()
+{
+    string idForParser;
+
+    // check if config-key for config parser is provided
+    if (fVarMap.count("config-key"))
+    {
+        idForParser = fVarMap["config-key"].as<string>();
+    }
+    else if (fVarMap.count("id"))
+    {
+        idForParser = fVarMap["id"].as<string>();
+    }
+
+    UpdateChannelMap(parser::SUBOPT().UserParser(fVarMap.at("channel-config").as<vector<string>>(), idForParser));
+}
+
 void FairMQProgOptions::ParseCmdLine(const int argc, char const* const* argv, bool allowUnregistered)
 {
     fVarMap.clear();
@@ -268,6 +285,7 @@ void FairMQProgOptions::UpdateMQValues()
             string rcvBufSizeKey = "chans." + p.first + "." + to_string(index) + ".rcvBufSize";
             string sndKernelSizeKey = "chans." + p.first + "." + to_string(index) + ".sndKernelSize";
             string rcvKernelSizeKey = "chans." + p.first + "." + to_string(index) + ".rcvKernelSize";
+            string lingerKey = "chans." + p.first + "." + to_string(index) + ".linger";
             string rateLoggingKey = "chans." + p.first + "." + to_string(index) + ".rateLogging";
 
             fChannelKeyMap[typeKey] = ChannelKey{p.first, index, "type"};
@@ -278,6 +296,7 @@ void FairMQProgOptions::UpdateMQValues()
             fChannelKeyMap[rcvBufSizeKey] = ChannelKey{p.first, index, "rcvBufSize"};
             fChannelKeyMap[sndKernelSizeKey] = ChannelKey{p.first, index, "sndKernelSize"};
             fChannelKeyMap[rcvKernelSizeKey] = ChannelKey{p.first, index, "rcvkernelSize"};
+            fChannelKeyMap[lingerKey] = ChannelKey{p.first, index, "linger"};
             fChannelKeyMap[rateLoggingKey] = ChannelKey{p.first, index, "rateLogging"};
 
             UpdateVarMap<string>(typeKey, channel.GetType());
@@ -288,6 +307,7 @@ void FairMQProgOptions::UpdateMQValues()
             UpdateVarMap<int>(rcvBufSizeKey, channel.GetRcvBufSize());
             UpdateVarMap<int>(sndKernelSizeKey, channel.GetSndKernelSize());
             UpdateVarMap<int>(rcvKernelSizeKey, channel.GetRcvKernelSize());
+            UpdateVarMap<int>(lingerKey, channel.GetLinger());
             UpdateVarMap<int>(rateLoggingKey, channel.GetRateLogging());
 
             index++;
@@ -343,6 +363,24 @@ int FairMQProgOptions::UpdateChannelValue(const string& channelName, int index,
         return 0;
     }
 
+    if (member == "sndKernelSize")
+    {
+        fFairMQChannelMap.at(channelName).at(index).UpdateSndKernelSize(val);
+        return 0;
+    }
+
+    if (member == "rcvKernelSize")
+    {
+        fFairMQChannelMap.at(channelName).at(index).UpdateRcvKernelSize(val);
+        return 0;
+    }
+
+    if (member == "linger")
+    {
+        fFairMQChannelMap.at(channelName).at(index).UpdateLinger(val);
+        return 0;
+    }
+
     if (member == "rateLogging")
     {
         fFairMQChannelMap.at(channelName).at(index).UpdateRateLogging(val);

fairmq/options/FairMQProgOptions.h

@@ -59,13 +59,13 @@ class FairMQProgOptions
         // update variable map
         UpdateVarMap<typename std::decay<T>::type>(key, val);
 
-        // update FairMQChannel map if the key is a channel key
-        if (std::is_same<T, int>::value || std::is_same<T, std::string>::value)
+        if (key == "channel-config")
         {
-            if (fChannelKeyMap.count(key))
-            {
-                UpdateChannelValue(fChannelKeyMap.at(key).channel, fChannelKeyMap.at(key).index, fChannelKeyMap.at(key).member, val);
-            }
+            ParseChannelsFromCmdLine();
+        }
+        else if (fChannelKeyMap.count(key))
+        {
+            UpdateChannelValue(fChannelKeyMap.at(key).channel, fChannelKeyMap.at(key).index, fChannelKeyMap.at(key).member, val);
         }
 
         lock.unlock();
@@ -210,6 +210,12 @@ class FairMQProgOptions
     }
 
     int UpdateChannelMap(const FairMQChannelMap& map);
+    template<typename T>
+    int UpdateChannelValue(const std::string&, int, const std::string&, T)
+    {
+        LOG(error)  << "update of FairMQChannel map failed, because value type not supported";
+        return 1;
+    }
     int UpdateChannelValue(const std::string& channelName, int index, const std::string& member, const std::string& val);
     int UpdateChannelValue(const std::string& channelName, int index, const std::string& member, int val);
 
@@ -223,6 +229,7 @@ class FairMQProgOptions
         vm[key].value() = boost::any(val);
     }
 
+    void ParseChannelsFromCmdLine();
 };
 
 #endif /* FAIRMQPROGOPTIONS_H */

fairmq/options/FairMQSuboptParser.h

@@ -56,6 +56,7 @@ struct SUBOPT
         RCVBUFSIZE,     // size of the receive queue
         SNDKERNELSIZE,
         RCVKERNELSIZE,
+        LINGER,
         RATELOGGING,    // logging rate
         NUMSOCKETS,
         lastsocketkey
@@ -71,6 +72,7 @@ struct SUBOPT
         /*[RCVBUFSIZE]    = */ "rcvBufSize",
         /*[SNDKERNELSIZE] = */ "sndKernelSize",
         /*[RCVKERNELSIZE] = */ "rcvKernelSize",
+        /*[LINGER]        = */ "linger",
         /*[RATELOGGING]   = */ "rateLogging",
         /*[NUMSOCKETS]    = */ "numSockets",
         nullptr

fairmq/run/runBenchmarkSampler.cxx

@@ -16,7 +16,9 @@ void addCustomOptions(bpo::options_description& options)
     options.add_options()
         ("out-channel", bpo::value<std::string>()->default_value("data"), "Name of the output channel")
         ("same-msg", bpo::value<bool>()->default_value(false), "Re-send the same message, or recreate for each iteration")
-        ("msg-size", bpo::value<int>()->default_value(1000000), "Message size in bytes")
+        ("multipart", bpo::value<bool>()->default_value(false), "Handle multipart payloads")
+        ("num-parts", bpo::value<size_t>()->default_value(1), "Number of parts to send. 1 will send single messages, not parts")
+        ("msg-size", bpo::value<size_t>()->default_value(1000000), "Message size in bytes")
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Number of run iterations (0 - infinite)")
         ("msg-rate", bpo::value<float>()->default_value(0), "Msg rate limit in maximum number of messages per second");
 }

fairmq/run/runMerger.cxx

@@ -16,7 +16,7 @@ void addCustomOptions(bpo::options_description& options)
     options.add_options()
         ("in-channel", bpo::value<std::string>()->default_value("data-in"), "Name of the input channel")
         ("out-channel", bpo::value<std::string>()->default_value("data-out"), "Name of the output channel")
-        ("multipart", bpo::value<int>()->default_value(1), "Handle multipart payloads");
+        ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
 FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)

fairmq/run/runMultiplier.cxx

@@ -16,7 +16,7 @@ void addCustomOptions(bpo::options_description& options)
     options.add_options()
         ("in-channel", bpo::value<std::string>()->default_value("data-in"), "Name of the input channel")
         ("out-channel", bpo::value<std::vector<std::string>>()->multitoken(), "Names of the output channels")
-        ("multipart", bpo::value<int>()->default_value(1), "Handle multipart payloads");
+        ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
 FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)

fairmq/run/runProxy.cxx

@@ -16,7 +16,7 @@ void addCustomOptions(bpo::options_description& options)
     options.add_options()
         ("in-channel", bpo::value<std::string>()->default_value("data-in"), "Name of the input channel")
         ("out-channel", bpo::value<std::string>()->default_value("data-out"), "Name of the output channel")
-        ("multipart", bpo::value<int>()->default_value(1), "Handle multipart payloads");
+        ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
 FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)

fairmq/run/runSink.cxx

@@ -15,7 +15,8 @@ void addCustomOptions(bpo::options_description& options)
 {
     options.add_options()
         ("in-channel", bpo::value<std::string>()->default_value("data"), "Name of the input channel")
-        ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Number of run iterations (0 - infinite)");
+        ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Number of run iterations (0 - infinite)")
+        ("multipart", bpo::value<bool>()->default_value(false), "Handle multipart payloads");
 }
 
 FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)

fairmq/run/runSplitter.cxx

@@ -16,7 +16,7 @@ void addCustomOptions(bpo::options_description& options)
     options.add_options()
         ("in-channel", bpo::value<std::string>()->default_value("data-in"), "Name of the input channel")
         ("out-channel", bpo::value<std::string>()->default_value("data-out"), "Name of the output channel")
-        ("multipart", bpo::value<int>()->default_value(1), "Handle multipart payloads");
+        ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
 FairMQDevicePtr getDevice(const FairMQProgOptions& /*config*/)

fairmq/run/startMQBenchmark.sh.in

@@ -5,7 +5,6 @@ export FAIRMQ_PATH=@FAIRMQ_BIN_DIR@
 maxIterations="0"
 msgSize="1000000"
 transport="zeromq"
-sameMsg="true"
 affinity="false"
 affinitySamp=""
 affinitySink=""
@@ -24,11 +23,7 @@ if [[ $3 =~ ^[a-z]+$ ]]; then
 fi
 
 if [[ $4 =~ ^[a-z]+$ ]]; then
-    sameMsg=$4
-fi
-
-if [[ $5 =~ ^[a-z]+$ ]]; then
-    affinity=$5
+    affinity=$4
 fi
 
 
@@ -45,12 +40,6 @@ fi
 
 echo "transport: $transport"
 
-if [ $sameMsg = "true" ]; then
-    echo "resend same message: yes, using Copy() method to resend the same message"
-else
-    echo "resend same message: no, allocating each message separately"
-fi
-
 if [ $affinity = "true" ]; then
     affinitySamp="taskset -c 0"
     affinitySink="taskset -c 1"
@@ -60,7 +49,7 @@ else
 fi
 
 echo ""
-echo "Usage: startBenchmark [message size=1000000] [number of iterations=0] [transport=zeromq/nanomsg/shmem] [resend same message=true] [affinity=false]"
+echo "Usage: startBenchmark [message size=1000000] [number of iterations=0] [transport=zeromq/nanomsg/shmem] [affinity=false]"
 
 SAMPLER="fairmq-bsampler"
 SAMPLER+=" --id bsampler1"
@@ -69,7 +58,7 @@ SAMPLER+=" --id bsampler1"
 SAMPLER+=" --transport $transport"
 SAMPLER+=" --severity debug"
 SAMPLER+=" --msg-size $msgSize"
-SAMPLER+=" --same-msg $sameMsg"
+SAMPLER+=" --num-parts 1"
 # SAMPLER+=" --msg-rate 1000"
 SAMPLER+=" --max-iterations $maxIterations"
 SAMPLER+=" --channel-config name=data,type=push,method=bind,address=tcp://127.0.0.1:5555"
@@ -84,6 +73,7 @@ SINK+=" --id sink1"
 #SINK+=" --control static"
 SINK+=" --transport $transport"
 SINK+=" --severity debug"
+SINK+=" --multipart false"
 SINK+=" --max-iterations $maxIterations"
 SINK+=" --channel-config name=data,type=pull,method=connect,address=tcp://127.0.0.1:5555"
 xterm -geometry 90x50+550+0 -hold -e $affinitySink @CMAKE_CURRENT_BINARY_DIR@/$SINK &

fairmq/shmem/FairMQMessageSHM.cxx

@@ -25,8 +25,9 @@ namespace bpt = ::boost::posix_time;
 atomic<bool> FairMQMessageSHM::fInterrupted(false);
 fair::mq::Transport FairMQMessageSHM::fTransportType = fair::mq::Transport::SHM;
 
-FairMQMessageSHM::FairMQMessageSHM(Manager& manager)
-    : fManager(manager)
+FairMQMessageSHM::FairMQMessageSHM(Manager& manager, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fManager(manager)
     , fMessage()
     , fQueued(false)
     , fMetaCreated(false)
@@ -44,8 +45,9 @@ FairMQMessageSHM::FairMQMessageSHM(Manager& manager)
     fMetaCreated = true;
 }
 
-FairMQMessageSHM::FairMQMessageSHM(Manager& manager, const size_t size)
-    : fManager(manager)
+FairMQMessageSHM::FairMQMessageSHM(Manager& manager, const size_t size, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fManager(manager)
     , fMessage()
     , fQueued(false)
     , fMetaCreated(false)
@@ -59,8 +61,9 @@ FairMQMessageSHM::FairMQMessageSHM(Manager& manager, const size_t size)
     InitializeChunk(size);
 }
 
-FairMQMessageSHM::FairMQMessageSHM(Manager& manager, void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
-    : fManager(manager)
+FairMQMessageSHM::FairMQMessageSHM(Manager& manager, void* data, const size_t size, fairmq_free_fn* ffn, void* hint, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fManager(manager)
     , fMessage()
     , fQueued(false)
     , fMetaCreated(false)
@@ -85,8 +88,9 @@ FairMQMessageSHM::FairMQMessageSHM(Manager& manager, void* data, const size_t si
     }
 }
 
-FairMQMessageSHM::FairMQMessageSHM(Manager& manager, FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
-    : fManager(manager)
+FairMQMessageSHM::FairMQMessageSHM(Manager& manager, FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fManager(manager)
     , fMessage()
     , fQueued(false)
     , fMetaCreated(false)

fairmq/shmem/FairMQMessageSHM.h

@@ -22,15 +22,15 @@
 
 class FairMQSocketSHM;
 
-class FairMQMessageSHM : public FairMQMessage
+class FairMQMessageSHM final : public FairMQMessage
 {
     friend class FairMQSocketSHM;
 
   public:
-    FairMQMessageSHM(fair::mq::shmem::Manager& manager);
-    FairMQMessageSHM(fair::mq::shmem::Manager& manager, const size_t size);
-    FairMQMessageSHM(fair::mq::shmem::Manager& manager, void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr);
-    FairMQMessageSHM(fair::mq::shmem::Manager& manager, FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0);
+    FairMQMessageSHM(fair::mq::shmem::Manager& manager, FairMQTransportFactory* factory = nullptr);
+    FairMQMessageSHM(fair::mq::shmem::Manager& manager, const size_t size, FairMQTransportFactory* factory = nullptr);
+    FairMQMessageSHM(fair::mq::shmem::Manager& manager, void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr, FairMQTransportFactory* factory = nullptr);
+    FairMQMessageSHM(fair::mq::shmem::Manager& manager, FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, FairMQTransportFactory* factory = nullptr);
 
     FairMQMessageSHM(const FairMQMessageSHM&) = delete;
     FairMQMessageSHM operator=(const FairMQMessageSHM&) = delete;

fairmq/shmem/FairMQPollerSHM.cxx

@@ -13,6 +13,7 @@
  */
 
 #include "FairMQPollerSHM.h"
+#include "FairMQSocketSHM.h"
 #include "FairMQLogger.h"
 
 #include <zmq.h>
@@ -29,19 +30,19 @@ FairMQPollerSHM::FairMQPollerSHM(const vector<FairMQChannel>& channels)
 
     for (int i = 0; i < fNumItems; ++i)
     {
-        fItems[i].socket = channels.at(i).GetSocket().GetSocket();
+        fItems[i].socket = static_cast<const FairMQSocketSHM*>(&(channels.at(i).GetSocket()))->GetSocket();
         fItems[i].fd = 0;
         fItems[i].revents = 0;
 
         int type = 0;
         size_t size = sizeof(type);
-        zmq_getsockopt(channels.at(i).GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+        zmq_getsockopt(static_cast<const FairMQSocketSHM*>(&(channels.at(i).GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
         SetItemEvents(fItems[i], type);
     }
 }
 
-FairMQPollerSHM::FairMQPollerSHM(const vector<const FairMQChannel*>& channels)
+FairMQPollerSHM::FairMQPollerSHM(const vector<FairMQChannel*>& channels)
     : fItems()
     , fNumItems(0)
     , fOffsetMap()
@@ -51,13 +52,13 @@ FairMQPollerSHM::FairMQPollerSHM(const vector<const FairMQChannel*>& channels)
 
     for (int i = 0; i < fNumItems; ++i)
     {
-        fItems[i].socket = channels.at(i)->GetSocket().GetSocket();
+        fItems[i].socket = static_cast<const FairMQSocketSHM*>(&(channels.at(i)->GetSocket()))->GetSocket();
         fItems[i].fd = 0;
         fItems[i].revents = 0;
 
         int type = 0;
         size_t size = sizeof(type);
-        zmq_getsockopt(channels.at(i)->GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+        zmq_getsockopt(static_cast<const FairMQSocketSHM*>(&(channels.at(i)->GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
         SetItemEvents(fItems[i], type);
     }
@@ -88,13 +89,13 @@ FairMQPollerSHM::FairMQPollerSHM(const unordered_map<string, vector<FairMQChanne
             {
                 index = fOffsetMap[channel] + i;
 
-                fItems[index].socket = channelsMap.at(channel).at(i).GetSocket().GetSocket();
+                fItems[index].socket = static_cast<const FairMQSocketSHM*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket();
                 fItems[index].fd = 0;
                 fItems[index].revents = 0;
 
                 int type = 0;
                 size_t size = sizeof(type);
-                zmq_getsockopt(channelsMap.at(channel).at(i).GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+                zmq_getsockopt(static_cast<const FairMQSocketSHM*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
                 SetItemEvents(fItems[index], type);
             }
@@ -108,29 +109,6 @@ FairMQPollerSHM::FairMQPollerSHM(const unordered_map<string, vector<FairMQChanne
     }
 }
 
-FairMQPollerSHM::FairMQPollerSHM(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket)
-    : fItems()
-    , fNumItems(2)
-    , fOffsetMap()
-{
-    fItems = new zmq_pollitem_t[fNumItems];
-
-    fItems[0].socket = cmdSocket.GetSocket();
-    fItems[0].fd = 0;
-    fItems[0].events = ZMQ_POLLIN;
-    fItems[0].revents = 0;
-
-    fItems[1].socket = dataSocket.GetSocket();
-    fItems[1].fd = 0;
-    fItems[1].revents = 0;
-
-    int type = 0;
-    size_t size = sizeof(type);
-    zmq_getsockopt(dataSocket.GetSocket(), ZMQ_TYPE, &type, &size);
-
-    SetItemEvents(fItems[1], type);
-}
-
 void FairMQPollerSHM::SetItemEvents(zmq_pollitem_t& item, const int type)
 {
     if (type == ZMQ_REQ || type == ZMQ_REP || type == ZMQ_PAIR || type == ZMQ_DEALER || type == ZMQ_ROUTER)

fairmq/shmem/FairMQPollerSHM.h

@@ -19,14 +19,14 @@
 
 class FairMQChannel;
 
-class FairMQPollerSHM : public FairMQPoller
+class FairMQPollerSHM final : public FairMQPoller
 {
     friend class FairMQChannel;
     friend class FairMQTransportFactorySHM;
 
   public:
     FairMQPollerSHM(const std::vector<FairMQChannel>& channels);
-    FairMQPollerSHM(const std::vector<const FairMQChannel*>& channels);
+    FairMQPollerSHM(const std::vector<FairMQChannel*>& channels);
     FairMQPollerSHM(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList);
 
     FairMQPollerSHM(const FairMQPollerSHM&) = delete;
@@ -43,12 +43,10 @@ class FairMQPollerSHM : public FairMQPoller
     ~FairMQPollerSHM() override;
 
   private:
-    FairMQPollerSHM(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket);
-
     zmq_pollitem_t* fItems;
     int fNumItems;
 
     std::unordered_map<std::string, int> fOffsetMap;
 };
 
-#endif /* FAIRMQPOLLERSHM_H_ */
+#endif /* FAIRMQPOLLERSHM_H_ */

fairmq/shmem/FairMQSocketSHM.cxx

@@ -11,6 +11,7 @@
 #include "FairMQMessageSHM.h"
 #include "FairMQUnmanagedRegionSHM.h"
 #include "FairMQLogger.h"
+#include <fairmq/Tools.h>
 
 #include <zmq.h>
 
@@ -18,6 +19,7 @@
 
 using namespace std;
 using namespace fair::mq::shmem;
+using namespace fair::mq;
 
 atomic<bool> FairMQSocketSHM::fInterrupted(false);
 
@@ -109,18 +111,13 @@ void FairMQSocketSHM::Connect(const string& address)
     }
 }
 
-int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int timeout) { return SendImpl(msg, 0, timeout); }
-int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int timeout) { return ReceiveImpl(msg, 0, timeout); }
-int64_t FairMQSocketSHM::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return SendImpl(msgVec, 0, timeout); }
-int64_t FairMQSocketSHM::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return ReceiveImpl(msgVec, 0, timeout); }
-
-int FairMQSocketSHM::TrySend(FairMQMessagePtr& msg) { return SendImpl(msg, ZMQ_DONTWAIT, 0); }
-int FairMQSocketSHM::TryReceive(FairMQMessagePtr& msg) { return ReceiveImpl(msg, ZMQ_DONTWAIT, 0); }
-int64_t FairMQSocketSHM::TrySend(vector<unique_ptr<FairMQMessage>>& msgVec) { return SendImpl(msgVec, ZMQ_DONTWAIT, 0); }
-int64_t FairMQSocketSHM::TryReceive(vector<unique_ptr<FairMQMessage>>& msgVec) { return ReceiveImpl(msgVec, ZMQ_DONTWAIT, 0); }
-
-int FairMQSocketSHM::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
+int FairMQSocketSHM::Send(FairMQMessagePtr& msg, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     while (true && !fInterrupted)
@@ -144,7 +141,7 @@ int FairMQSocketSHM::SendImpl(FairMQMessagePtr& msg, const int flags, const int
         {
             if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fSndTimeout;
                     if (elapsed >= timeout)
@@ -174,8 +171,13 @@ int FairMQSocketSHM::SendImpl(FairMQMessagePtr& msg, const int flags, const int
     return -1;
 }
 
-int FairMQSocketSHM::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
+int FairMQSocketSHM::Receive(FairMQMessagePtr& msg, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     zmq_msg_t* msgPtr = static_cast<FairMQMessageSHM*>(msg.get())->GetMessage();
@@ -216,7 +218,7 @@ int FairMQSocketSHM::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const i
         {
             if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fRcvTimeout;
                     if (elapsed >= timeout)
@@ -244,13 +246,18 @@ int FairMQSocketSHM::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const i
     }
 }
 
-int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
+int64_t FairMQSocketSHM::Send(vector<FairMQMessagePtr>& msgVec, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     const unsigned int vecSize = msgVec.size();
     int elapsed = 0;
 
     if (vecSize == 1) {
-        return SendImpl(msgVec.back(), flags, timeout);
+        return Send(msgVec.back(), timeout);
     }
 
     // put it into zmq message
@@ -297,7 +304,7 @@ int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
         {
             if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fSndTimeout;
                     if (elapsed >= timeout)
@@ -332,8 +339,13 @@ int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
     return -1;
 }
 
-int64_t FairMQSocketSHM::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
+int64_t FairMQSocketSHM::Receive(vector<FairMQMessagePtr>& msgVec, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     zmq_msg_t zmqMsg;
@@ -390,7 +402,7 @@ int64_t FairMQSocketSHM::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int
         {
             if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fRcvTimeout;
                     if (elapsed >= timeout)
@@ -455,12 +467,6 @@ void* FairMQSocketSHM::GetSocket() const
     return fSocket;
 }
 
-int FairMQSocketSHM::GetSocket(int) const
-{
-    // dummy method to comply with the interface. functionality not possible in zeromq.
-    return -1;
-}
-
 void FairMQSocketSHM::SetOption(const string& option, const void* value, size_t valueSize)
 {
     if (zmq_setsockopt(fSocket, GetConstant(option), value, valueSize) < 0)
@@ -477,6 +483,91 @@ void FairMQSocketSHM::GetOption(const string& option, void* value, size_t* value
     }
 }
 
+void FairMQSocketSHM::SetLinger(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_LINGER, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_LINGER, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketSHM::GetLinger() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_LINGER, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_LINGER, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketSHM::SetSndBufSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_SNDHWM, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_SNDHWM, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketSHM::GetSndBufSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_SNDHWM, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDHWM, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketSHM::SetRcvBufSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_RCVHWM, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_RCVHWM, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketSHM::GetRcvBufSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_RCVHWM, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVHWM, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketSHM::SetSndKernelSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_SNDBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDBUF, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketSHM::GetSndKernelSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_SNDBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDBUF, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketSHM::SetRcvKernelSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_RCVBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVBUF, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketSHM::GetRcvKernelSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_RCVBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVBUF, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
 unsigned long FairMQSocketSHM::GetBytesTx() const
 {
     return fBytesTx;
@@ -497,112 +588,6 @@ unsigned long FairMQSocketSHM::GetMessagesRx() const
     return fMessagesRx;
 }
 
-bool FairMQSocketSHM::SetSendTimeout(const int timeout, const string& address, const string& method)
-{
-    fSndTimeout = timeout;
-    if (method == "bind")
-    {
-        if (zmq_unbind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_bind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed binding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else if (method == "connect")
-    {
-        if (zmq_disconnect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_connect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else
-    {
-        LOG(error) << "timeout failed - unknown method provided!";
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketSHM::GetSendTimeout() const
-{
-    return fSndTimeout;
-}
-
-bool FairMQSocketSHM::SetReceiveTimeout(const int timeout, const string& address, const string& method)
-{
-    fRcvTimeout = timeout;
-    if (method == "bind")
-    {
-        if (zmq_unbind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_bind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed binding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else if (method == "connect")
-    {
-        if (zmq_disconnect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_connect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else
-    {
-        LOG(error) << "timeout failed - unknown method provided!";
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketSHM::GetReceiveTimeout() const
-{
-    return fRcvTimeout;
-}
-
 int FairMQSocketSHM::GetConstant(const string& constant)
 {
     if (constant == "") return 0;

fairmq/shmem/FairMQSocketSHM.h

@@ -16,7 +16,7 @@
 #include <atomic>
 #include <memory> // unique_ptr
 
-class FairMQSocketSHM : public FairMQSocket
+class FairMQSocketSHM final : public FairMQSocket
 {
   public:
     FairMQSocketSHM(fair::mq::shmem::Manager& manager, const std::string& type, const std::string& name, const std::string& id = "", void* context = nullptr);
@@ -28,18 +28,12 @@ class FairMQSocketSHM : public FairMQSocket
     bool Bind(const std::string& address) override;
     void Connect(const std::string& address) override;
 
-    int Send(FairMQMessagePtr& msg, const int timeout = 0) override;
-    int Receive(FairMQMessagePtr& msg, const int timeout = 0) override;
-    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
-    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
+    int Send(FairMQMessagePtr& msg, const int timeout = -1) override;
+    int Receive(FairMQMessagePtr& msg, const int timeout = -1) override;
+    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
+    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
 
-    int TrySend(FairMQMessagePtr& msg) override;
-    int TryReceive(FairMQMessagePtr& msg) override;
-    int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
-    int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
-
-    void* GetSocket() const override;
-    int GetSocket(int nothing) const override;
+    void* GetSocket() const;
 
     void Close() override;
 
@@ -49,16 +43,22 @@ class FairMQSocketSHM : public FairMQSocket
     void SetOption(const std::string& option, const void* value, size_t valueSize) override;
     void GetOption(const std::string& option, void* value, size_t* valueSize) override;
 
+    void SetLinger(const int value) override;
+    int GetLinger() const override;
+    void SetSndBufSize(const int value) override;
+    int GetSndBufSize() const override;
+    void SetRcvBufSize(const int value) override;
+    int GetRcvBufSize() const override;
+    void SetSndKernelSize(const int value) override;
+    int GetSndKernelSize() const override;
+    void SetRcvKernelSize(const int value) override;
+    int GetRcvKernelSize() const override;
+
     unsigned long GetBytesTx() const override;
     unsigned long GetBytesRx() const override;
     unsigned long GetMessagesTx() const override;
     unsigned long GetMessagesRx() const override;
 
-    bool SetSendTimeout(const int timeout, const std::string& address, const std::string& method) override;
-    int GetSendTimeout() const override;
-    bool SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method) override;
-    int GetReceiveTimeout() const override;
-
     static int GetConstant(const std::string& constant);
 
     ~FairMQSocketSHM() override;
@@ -76,12 +76,6 @@ class FairMQSocketSHM : public FairMQSocket
 
     int fSndTimeout;
     int fRcvTimeout;
-
-    int SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
-    int ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
-
-    int64_t SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
-    int64_t ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
 };
 
 #endif /* FAIRMQSOCKETSHM_H_ */

fairmq/shmem/FairMQTransportFactorySHM.cxx

@@ -213,24 +213,24 @@ void FairMQTransportFactorySHM::SendHeartbeats()
     }
 }
 
-FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage() const
+FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage()
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager));
+    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, this));
 }
 
-FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(const size_t size) const
+FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(const size_t size)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, size));
+    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, size, this));
 }
 
-FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint) const
+FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, data, size, ffn, hint));
+    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, data, size, ffn, hint, this));
 }
 
-FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint) const
+FairMQMessagePtr FairMQTransportFactorySHM::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, region, data, size, hint));
+    return unique_ptr<FairMQMessage>(new FairMQMessageSHM(*fManager, region, data, size, hint, this));
 }
 
 FairMQSocketPtr FairMQTransportFactorySHM::CreateSocket(const string& type, const string& name) const
@@ -244,7 +244,7 @@ FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const vector<FairMQChann
     return unique_ptr<FairMQPoller>(new FairMQPollerSHM(channels));
 }
 
-FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const vector<const FairMQChannel*>& channels) const
+FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const vector<FairMQChannel*>& channels) const
 {
     return unique_ptr<FairMQPoller>(new FairMQPollerSHM(channels));
 }
@@ -254,11 +254,6 @@ FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const unordered_map<stri
     return unique_ptr<FairMQPoller>(new FairMQPollerSHM(channelsMap, channelList));
 }
 
-FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const
-{
-    return unique_ptr<FairMQPoller>(new FairMQPollerSHM(cmdSocket, dataSocket));
-}
-
 FairMQUnmanagedRegionPtr FairMQTransportFactorySHM::CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const
 {
     return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionSHM(*fManager, size, callback));

fairmq/shmem/FairMQTransportFactorySHM.h

@@ -26,24 +26,23 @@
 #include <thread>
 #include <atomic>
 
-class FairMQTransportFactorySHM : public FairMQTransportFactory
+class FairMQTransportFactorySHM final : public FairMQTransportFactory
 {
   public:
     FairMQTransportFactorySHM(const std::string& id = "", const FairMQProgOptions* config = nullptr);
     FairMQTransportFactorySHM(const FairMQTransportFactorySHM&) = delete;
     FairMQTransportFactorySHM operator=(const FairMQTransportFactorySHM&) = delete;
 
-    FairMQMessagePtr CreateMessage() const override;
-    FairMQMessagePtr CreateMessage(const size_t size) const override;
-    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const override;
-    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) const override;
+    FairMQMessagePtr CreateMessage() override;
+    FairMQMessagePtr CreateMessage(const size_t size) override;
+    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override;
+    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override;
 
     FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) const override;
 
     FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override;
-    FairMQPollerPtr CreatePoller(const std::vector<const FairMQChannel*>& channels) const override;
+    FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override;
     FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override;
-    FairMQPollerPtr CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const override;
 
     FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr) const override;
 
@@ -51,6 +50,7 @@ class FairMQTransportFactorySHM : public FairMQTransportFactory
 
     void Interrupt() override { FairMQSocketSHM::Interrupt(); }
     void Resume() override { FairMQSocketSHM::Resume(); }
+    void Reset() override {}
 
     ~FairMQTransportFactorySHM() override;
 

fairmq/shmem/FairMQUnmanagedRegionSHM.h

@@ -19,7 +19,7 @@
 
 #include <cstddef> // size_t
 
-class FairMQUnmanagedRegionSHM : public FairMQUnmanagedRegion
+class FairMQUnmanagedRegionSHM final : public FairMQUnmanagedRegion
 {
     friend class FairMQSocketSHM;
     friend class FairMQMessageSHM;

fairmq/shmem/Monitor.cxx

@@ -443,9 +443,9 @@ void Monitor::PrintQueues()
         {
             cout << "found " << queues->size() << " queue(s):" << endl;
 
-            for (unsigned int i = 0; i < queues->size(); ++i)
+            for (const auto& queue : *queues)
             {
-                string name(queues->at(i).c_str());
+                string name(queue.c_str());
                 cout << '\t' << name << " : ";
                 atomic<int>* queueSize = segment.find<atomic<int>>(name.c_str()).first;
                 if (queueSize)

fairmq/zeromq/FairMQMessageZMQ.cxx

@@ -17,6 +17,7 @@
 #include "FairMQLogger.h"
 #include <fairmq/Tools.h>
 #include "FairMQUnmanagedRegionZMQ.h"
+#include <FairMQTransportFactory.h>
 
 #include <cstring>
 
@@ -24,8 +25,9 @@ using namespace std;
 
 fair::mq::Transport FairMQMessageZMQ::fTransportType = fair::mq::Transport::ZMQ;
 
-FairMQMessageZMQ::FairMQMessageZMQ()
-    : fUsedSizeModified(false)
+FairMQMessageZMQ::FairMQMessageZMQ(FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fUsedSizeModified(false)
     , fUsedSize()
     , fMsg(fair::mq::tools::make_unique<zmq_msg_t>())
     , fViewMsg(nullptr)
@@ -36,8 +38,9 @@ FairMQMessageZMQ::FairMQMessageZMQ()
     }
 }
 
-FairMQMessageZMQ::FairMQMessageZMQ(const size_t size)
-    : fUsedSizeModified(false)
+FairMQMessageZMQ::FairMQMessageZMQ(const size_t size, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fUsedSizeModified(false)
     , fUsedSize(size)
     , fMsg(fair::mq::tools::make_unique<zmq_msg_t>())
     , fViewMsg(nullptr)
@@ -48,8 +51,9 @@ FairMQMessageZMQ::FairMQMessageZMQ(const size_t size)
     }
 }
 
-FairMQMessageZMQ::FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
-    : fUsedSizeModified(false)
+FairMQMessageZMQ::FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn* ffn, void* hint, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fUsedSizeModified(false)
     , fUsedSize()
     , fMsg(fair::mq::tools::make_unique<zmq_msg_t>())
     , fViewMsg(nullptr)
@@ -60,8 +64,9 @@ FairMQMessageZMQ::FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn
     }
 }
 
-FairMQMessageZMQ::FairMQMessageZMQ(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
-    : fUsedSizeModified(false)
+FairMQMessageZMQ::FairMQMessageZMQ(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint, FairMQTransportFactory* factory)
+    : FairMQMessage{factory}
+    , fUsedSizeModified(false)
     , fUsedSize()
     , fMsg(fair::mq::tools::make_unique<zmq_msg_t>())
     , fViewMsg(nullptr)

fairmq/zeromq/FairMQMessageZMQ.h

@@ -23,18 +23,19 @@
 
 #include "FairMQMessage.h"
 #include "FairMQUnmanagedRegion.h"
+class FairMQTransportFactory;
 
 class FairMQSocketZMQ;
 
-class FairMQMessageZMQ : public FairMQMessage
+class FairMQMessageZMQ final : public FairMQMessage
 {
     friend class FairMQSocketZMQ;
 
   public:
-    FairMQMessageZMQ();
-    FairMQMessageZMQ(const size_t size);
-    FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr);
-    FairMQMessageZMQ(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0);
+    FairMQMessageZMQ(FairMQTransportFactory* = nullptr);
+    FairMQMessageZMQ(const size_t size, FairMQTransportFactory* = nullptr);
+    FairMQMessageZMQ(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr, FairMQTransportFactory* = nullptr);
+    FairMQMessageZMQ(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, FairMQTransportFactory* = nullptr);
 
     void Rebuild() override;
     void Rebuild(const size_t size) override;

fairmq/zeromq/FairMQPollerZMQ.cxx

@@ -15,6 +15,7 @@
 #include <zmq.h>
 
 #include "FairMQPollerZMQ.h"
+#include "FairMQSocketZMQ.h"
 #include "FairMQLogger.h"
 
 using namespace std;
@@ -29,20 +30,20 @@ FairMQPollerZMQ::FairMQPollerZMQ(const vector<FairMQChannel>& channels)
 
     for (int i = 0; i < fNumItems; ++i)
     {
-        fItems[i].socket = channels.at(i).GetSocket().GetSocket();
+        fItems[i].socket = static_cast<const FairMQSocketZMQ*>(&(channels.at(i).GetSocket()))->GetSocket();
         fItems[i].fd = 0;
         fItems[i].revents = 0;
 
         int type = 0;
         size_t size = sizeof(type);
-        zmq_getsockopt(channels.at(i).GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+        zmq_getsockopt(static_cast<const FairMQSocketZMQ*>(&(channels.at(i).GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
         SetItemEvents(fItems[i], type);
     }
 }
 
 
-FairMQPollerZMQ::FairMQPollerZMQ(const std::vector<const FairMQChannel*>& channels)
+FairMQPollerZMQ::FairMQPollerZMQ(const std::vector<FairMQChannel*>& channels)
     : fItems()
     , fNumItems(0)
     , fOffsetMap()
@@ -52,13 +53,13 @@ FairMQPollerZMQ::FairMQPollerZMQ(const std::vector<const FairMQChannel*>& channe
 
     for (int i = 0; i < fNumItems; ++i)
     {
-        fItems[i].socket = channels.at(i)->GetSocket().GetSocket();
+        fItems[i].socket = static_cast<const FairMQSocketZMQ*>(&(channels.at(i)->GetSocket()))->GetSocket();
         fItems[i].fd = 0;
         fItems[i].revents = 0;
 
         int type = 0;
         size_t size = sizeof(type);
-        zmq_getsockopt(channels.at(i)->GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+        zmq_getsockopt(static_cast<const FairMQSocketZMQ*>(&(channels.at(i)->GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
         SetItemEvents(fItems[i], type);
     }
@@ -89,13 +90,13 @@ FairMQPollerZMQ::FairMQPollerZMQ(const unordered_map<string, vector<FairMQChanne
             {
                 index = fOffsetMap[channel] + i;
 
-                fItems[index].socket = channelsMap.at(channel).at(i).GetSocket().GetSocket();
+                fItems[index].socket = static_cast<const FairMQSocketZMQ*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket();
                 fItems[index].fd = 0;
                 fItems[index].revents = 0;
 
                 int type = 0;
                 size_t size = sizeof(type);
-                zmq_getsockopt(channelsMap.at(channel).at(i).GetSocket().GetSocket(), ZMQ_TYPE, &type, &size);
+                zmq_getsockopt(static_cast<const FairMQSocketZMQ*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket(), ZMQ_TYPE, &type, &size);
 
                 SetItemEvents(fItems[index], type);
             }
@@ -109,29 +110,6 @@ FairMQPollerZMQ::FairMQPollerZMQ(const unordered_map<string, vector<FairMQChanne
     }
 }
 
-FairMQPollerZMQ::FairMQPollerZMQ(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket)
-    : fItems()
-    , fNumItems(2)
-    , fOffsetMap()
-{
-    fItems = new zmq_pollitem_t[fNumItems];
-
-    fItems[0].socket = cmdSocket.GetSocket();
-    fItems[0].fd = 0;
-    fItems[0].events = ZMQ_POLLIN;
-    fItems[0].revents = 0;
-
-    fItems[1].socket = dataSocket.GetSocket();
-    fItems[1].fd = 0;
-    fItems[1].revents = 0;
-
-    int type = 0;
-    size_t size = sizeof(type);
-    zmq_getsockopt(dataSocket.GetSocket(), ZMQ_TYPE, &type, &size);
-
-    SetItemEvents(fItems[1], type);
-}
-
 void FairMQPollerZMQ::SetItemEvents(zmq_pollitem_t& item, const int type)
 {
     if (type == ZMQ_REQ || type == ZMQ_REP || type == ZMQ_PAIR || type == ZMQ_DEALER || type == ZMQ_ROUTER)

fairmq/zeromq/FairMQPollerZMQ.h

@@ -27,14 +27,14 @@
 
 class FairMQChannel;
 
-class FairMQPollerZMQ : public FairMQPoller
+class FairMQPollerZMQ final : public FairMQPoller
 {
     friend class FairMQChannel;
     friend class FairMQTransportFactoryZMQ;
 
   public:
     FairMQPollerZMQ(const std::vector<FairMQChannel>& channels);
-    FairMQPollerZMQ(const std::vector<const FairMQChannel*>& channels);
+    FairMQPollerZMQ(const std::vector<FairMQChannel*>& channels);
     FairMQPollerZMQ(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList);
 
     FairMQPollerZMQ(const FairMQPollerZMQ&) = delete;
@@ -42,21 +42,19 @@ class FairMQPollerZMQ : public FairMQPoller
 
     void SetItemEvents(zmq_pollitem_t& item, const int type);
 
-    virtual void Poll(const int timeout);
-    virtual bool CheckInput(const int index);
-    virtual bool CheckOutput(const int index);
-    virtual bool CheckInput(const std::string& channelKey, const int index);
-    virtual bool CheckOutput(const std::string& channelKey, const int index);
+    void Poll(const int timeout) override;
+    bool CheckInput(const int index) override;
+    bool CheckOutput(const int index) override;
+    bool CheckInput(const std::string& channelKey, const int index) override;
+    bool CheckOutput(const std::string& channelKey, const int index) override;
 
-    virtual ~FairMQPollerZMQ();
+    ~FairMQPollerZMQ() override;
 
   private:
-    FairMQPollerZMQ(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket);
-
     zmq_pollitem_t* fItems;
     int fNumItems;
 
     std::unordered_map<std::string, int> fOffsetMap;
 };
 
-#endif /* FAIRMQPOLLERZMQ_H_ */
+#endif /* FAIRMQPOLLERZMQ_H_ */

fairmq/zeromq/FairMQSocketZMQ.cxx

@@ -9,12 +9,14 @@
 #include "FairMQSocketZMQ.h"
 #include "FairMQMessageZMQ.h"
 #include "FairMQLogger.h"
+#include <fairmq/Tools.h>
 
 #include <zmq.h>
 
 #include <cassert>
 
 using namespace std;
+using namespace fair::mq;
 
 atomic<bool> FairMQSocketZMQ::fInterrupted(false);
 
@@ -104,18 +106,13 @@ void FairMQSocketZMQ::Connect(const string& address)
     }
 }
 
-int FairMQSocketZMQ::Send(FairMQMessagePtr& msg, const int timeout) { return SendImpl(msg, 0, timeout); }
-int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg, const int timeout) { return ReceiveImpl(msg, 0, timeout); }
-int64_t FairMQSocketZMQ::Send(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return SendImpl(msgVec, 0, timeout); }
-int64_t FairMQSocketZMQ::Receive(vector<unique_ptr<FairMQMessage>>& msgVec, const int timeout) { return ReceiveImpl(msgVec, 0, timeout); }
-
-int FairMQSocketZMQ::TrySend(FairMQMessagePtr& msg) { return SendImpl(msg, ZMQ_DONTWAIT, 0); }
-int FairMQSocketZMQ::TryReceive(FairMQMessagePtr& msg) { return ReceiveImpl(msg, ZMQ_DONTWAIT, 0); }
-int64_t FairMQSocketZMQ::TrySend(vector<unique_ptr<FairMQMessage>>& msgVec) { return SendImpl(msgVec, ZMQ_DONTWAIT, 0); }
-int64_t FairMQSocketZMQ::TryReceive(vector<unique_ptr<FairMQMessage>>& msgVec) { return ReceiveImpl(msgVec, ZMQ_DONTWAIT, 0); }
-
-int FairMQSocketZMQ::SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
+int FairMQSocketZMQ::Send(FairMQMessagePtr& msg, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     static_cast<FairMQMessageZMQ*>(msg.get())->ApplyUsedSize();
@@ -134,7 +131,7 @@ int FairMQSocketZMQ::SendImpl(FairMQMessagePtr& msg, const int flags, const int
         {
             if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fSndTimeout;
                     if (elapsed >= timeout)
@@ -162,14 +159,18 @@ int FairMQSocketZMQ::SendImpl(FairMQMessagePtr& msg, const int flags, const int
     }
 }
 
-int FairMQSocketZMQ::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout)
+int FairMQSocketZMQ::Receive(FairMQMessagePtr& msg, const int timeout)
 {
-    int nbytes = -1;
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     while (true)
     {
-        nbytes = zmq_msg_recv(static_cast<FairMQMessageZMQ*>(msg.get())->GetMessage(), fSocket, flags);
+        int nbytes = zmq_msg_recv(static_cast<FairMQMessageZMQ*>(msg.get())->GetMessage(), fSocket, flags);
         if (nbytes >= 0)
         {
             fBytesRx += nbytes;
@@ -180,7 +181,7 @@ int FairMQSocketZMQ::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const i
         {
             if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
             {
-                if (timeout)
+                if (timeout > 0)
                 {
                     elapsed += fRcvTimeout;
                     if (elapsed >= timeout)
@@ -208,14 +209,21 @@ int FairMQSocketZMQ::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const i
     }
 }
 
-int64_t FairMQSocketZMQ::SendImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
+int64_t FairMQSocketZMQ::Send(vector<FairMQMessagePtr>& msgVec, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
+
     const unsigned int vecSize = msgVec.size();
 
     // Sending vector typicaly handles more then one part
     if (vecSize > 1)
     {
         int elapsed = 0;
+
         while (true)
         {
             int64_t totalSize = 0;
@@ -239,7 +247,7 @@ int64_t FairMQSocketZMQ::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
                     {
                         if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
                         {
-                            if (timeout)
+                            if (timeout > 0)
                             {
                                 elapsed += fSndTimeout;
                                 if (elapsed >= timeout)
@@ -278,7 +286,7 @@ int64_t FairMQSocketZMQ::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
     } // If there's only one part, send it as a regular message
     else if (vecSize == 1)
     {
-        return SendImpl(msgVec.back(), flags, timeout);
+        return Send(msgVec.back(), timeout);
     }
     else // if the vector is empty, something might be wrong
     {
@@ -287,8 +295,13 @@ int64_t FairMQSocketZMQ::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
     }
 }
 
-int64_t FairMQSocketZMQ::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, const int timeout)
+int64_t FairMQSocketZMQ::Receive(vector<FairMQMessagePtr>& msgVec, const int timeout)
 {
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     while (true)
@@ -311,7 +324,7 @@ int64_t FairMQSocketZMQ::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int
             {
                 if (!fInterrupted && ((flags & ZMQ_DONTWAIT) == 0))
                 {
-                    if (timeout)
+                    if (timeout > 0)
                     {
                         elapsed += fRcvTimeout;
                         if (elapsed >= timeout)
@@ -381,12 +394,6 @@ void* FairMQSocketZMQ::GetSocket() const
     return fSocket;
 }
 
-int FairMQSocketZMQ::GetSocket(int) const
-{
-    // 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)
 {
     if (zmq_setsockopt(fSocket, GetConstant(option), value, valueSize) < 0)
@@ -403,6 +410,91 @@ void FairMQSocketZMQ::GetOption(const string& option, void* value, size_t* value
     }
 }
 
+void FairMQSocketZMQ::SetLinger(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_LINGER, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_LINGER, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketZMQ::GetLinger() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_LINGER, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_LINGER, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketZMQ::SetSndBufSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_SNDHWM, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_SNDHWM, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketZMQ::GetSndBufSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_SNDHWM, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDHWM, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketZMQ::SetRcvBufSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_RCVHWM, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed setting ZMQ_RCVHWM, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketZMQ::GetRcvBufSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_RCVHWM, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVHWM, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketZMQ::SetSndKernelSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_SNDBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDBUF, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketZMQ::GetSndKernelSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_SNDBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_SNDBUF, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
+void FairMQSocketZMQ::SetRcvKernelSize(const int value)
+{
+    if (zmq_setsockopt(fSocket, ZMQ_RCVBUF, &value, sizeof(value)) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVBUF, reason: ", zmq_strerror(errno)));
+    }
+}
+
+int FairMQSocketZMQ::GetRcvKernelSize() const
+{
+    int value = 0;
+    size_t valueSize = sizeof(value);
+    if (zmq_getsockopt(fSocket, ZMQ_RCVBUF, &value, &valueSize) < 0) {
+        throw SocketError(tools::ToString("failed getting ZMQ_RCVBUF, reason: ", zmq_strerror(errno)));
+    }
+    return value;
+}
+
 unsigned long FairMQSocketZMQ::GetBytesTx() const
 {
     return fBytesTx;
@@ -423,112 +515,6 @@ unsigned long FairMQSocketZMQ::GetMessagesRx() const
     return fMessagesRx;
 }
 
-bool FairMQSocketZMQ::SetSendTimeout(const int timeout, const string& address, const string& method)
-{
-    fSndTimeout = timeout;
-    if (method == "bind")
-    {
-        if (zmq_unbind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_bind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed binding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else if (method == "connect")
-    {
-        if (zmq_disconnect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_connect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else
-    {
-        LOG(error) << "timeout failed - unknown method provided!";
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketZMQ::GetSendTimeout() const
-{
-    return fSndTimeout;
-}
-
-bool FairMQSocketZMQ::SetReceiveTimeout(const int timeout, const string& address, const string& method)
-{
-    fRcvTimeout = timeout;
-    if (method == "bind")
-    {
-        if (zmq_unbind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed unbinding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_bind(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed binding socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else if (method == "connect")
-    {
-        if (zmq_disconnect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed disconnecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_setsockopt(fSocket, ZMQ_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-        {
-            LOG(error) << "Failed setting option on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-        if (zmq_connect(fSocket, address.c_str()) != 0)
-        {
-            LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-            return false;
-        }
-    }
-    else
-    {
-        LOG(error) << "timeout failed - unknown method provided!";
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketZMQ::GetReceiveTimeout() const
-{
-    return fRcvTimeout;
-}
-
 int FairMQSocketZMQ::GetConstant(const string& constant)
 {
     if (constant == "") return 0;

fairmq/zeromq/FairMQSocketZMQ.h

@@ -16,7 +16,7 @@
 #include "FairMQSocket.h"
 #include "FairMQMessage.h"
 
-class FairMQSocketZMQ : public FairMQSocket
+class FairMQSocketZMQ final : public FairMQSocket
 {
   public:
     FairMQSocketZMQ(const std::string& type, const std::string& name, const std::string& id = "", void* context = nullptr);
@@ -28,18 +28,12 @@ class FairMQSocketZMQ : public FairMQSocket
     bool Bind(const std::string& address) override;
     void Connect(const std::string& address) override;
 
-    int Send(FairMQMessagePtr& msg, const int timeout = 0) override;
-    int Receive(FairMQMessagePtr& msg, const int timeout = 0) override;
-    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
-    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = 0) override;
+    int Send(FairMQMessagePtr& msg, const int timeout = -1) override;
+    int Receive(FairMQMessagePtr& msg, const int timeout = -1) override;
+    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
+    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
 
-    int TrySend(FairMQMessagePtr& msg) override;
-    int TryReceive(FairMQMessagePtr& msg) override;
-    int64_t TrySend(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
-    int64_t TryReceive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec) override;
-
-    void* GetSocket() const override;
-    int GetSocket(int nothing) const override;
+    void* GetSocket() const;
 
     void Close() override;
 
@@ -49,16 +43,22 @@ class FairMQSocketZMQ : public FairMQSocket
     void SetOption(const std::string& option, const void* value, size_t valueSize) override;
     void GetOption(const std::string& option, void* value, size_t* valueSize) override;
 
+    void SetLinger(const int value) override;
+    int GetLinger() const override;
+    void SetSndBufSize(const int value) override;
+    int GetSndBufSize() const override;
+    void SetRcvBufSize(const int value) override;
+    int GetRcvBufSize() const override;
+    void SetSndKernelSize(const int value) override;
+    int GetSndKernelSize() const override;
+    void SetRcvKernelSize(const int value) override;
+    int GetRcvKernelSize() const override;
+
     unsigned long GetBytesTx() const override;
     unsigned long GetBytesRx() const override;
     unsigned long GetMessagesTx() const override;
     unsigned long GetMessagesRx() const override;
 
-    bool SetSendTimeout(const int timeout, const std::string& address, const std::string& method) override;
-    int GetSendTimeout() const override;
-    bool SetReceiveTimeout(const int timeout, const std::string& address, const std::string& method) override;
-    int GetReceiveTimeout() const override;
-
     static int GetConstant(const std::string& constant);
 
     ~FairMQSocketZMQ() override;
@@ -75,12 +75,6 @@ class FairMQSocketZMQ : public FairMQSocket
 
     int fSndTimeout;
     int fRcvTimeout;
-
-    int SendImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
-    int ReceiveImpl(FairMQMessagePtr& msg, const int flags, const int timeout);
-
-    int64_t SendImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
-    int64_t ReceiveImpl(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int flags, const int timeout);
 };
 
 #endif /* FAIRMQSOCKETZMQ_H_ */

fairmq/zeromq/FairMQTransportFactoryZMQ.cxx

@@ -49,24 +49,24 @@ FairMQTransportFactoryZMQ::FairMQTransportFactoryZMQ(const string& id, const Fai
 
 }
 
-FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage() const
+FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage()
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ());
+    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(this));
 }
 
-FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(const size_t size) const
+FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(const size_t size)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(size));
+    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(size, this));
 }
 
-FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint) const
+FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(data, size, ffn, hint));
+    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(data, size, ffn, hint, this));
 }
 
-FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint) const
+FairMQMessagePtr FairMQTransportFactoryZMQ::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
 {
-    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(region, data, size, hint));
+    return unique_ptr<FairMQMessage>(new FairMQMessageZMQ(region, data, size, hint, this));
 }
 
 FairMQSocketPtr FairMQTransportFactoryZMQ::CreateSocket(const string& type, const string& name) const
@@ -80,7 +80,7 @@ FairMQPollerPtr FairMQTransportFactoryZMQ::CreatePoller(const vector<FairMQChann
     return unique_ptr<FairMQPoller>(new FairMQPollerZMQ(channels));
 }
 
-FairMQPollerPtr FairMQTransportFactoryZMQ::CreatePoller(const std::vector<const FairMQChannel*>& channels) const
+FairMQPollerPtr FairMQTransportFactoryZMQ::CreatePoller(const std::vector<FairMQChannel*>& channels) const
 {
     return unique_ptr<FairMQPoller>(new FairMQPollerZMQ(channels));
 }
@@ -90,11 +90,6 @@ FairMQPollerPtr FairMQTransportFactoryZMQ::CreatePoller(const unordered_map<stri
     return unique_ptr<FairMQPoller>(new FairMQPollerZMQ(channelsMap, channelList));
 }
 
-FairMQPollerPtr FairMQTransportFactoryZMQ::CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const
-{
-    return unique_ptr<FairMQPoller>(new FairMQPollerZMQ(cmdSocket, dataSocket));
-}
-
 FairMQUnmanagedRegionPtr FairMQTransportFactoryZMQ::CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const
 {
     return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionZMQ(size, callback));

fairmq/zeromq/FairMQTransportFactoryZMQ.h

@@ -25,7 +25,7 @@
 #include "FairMQUnmanagedRegionZMQ.h"
 #include <options/FairMQProgOptions.h>
 
-class FairMQTransportFactoryZMQ : public FairMQTransportFactory
+class FairMQTransportFactoryZMQ final : public FairMQTransportFactory
 {
   public:
     FairMQTransportFactoryZMQ(const std::string& id = "", const FairMQProgOptions* config = nullptr);
@@ -34,17 +34,16 @@ class FairMQTransportFactoryZMQ : public FairMQTransportFactory
 
     ~FairMQTransportFactoryZMQ() override;
 
-    FairMQMessagePtr CreateMessage() const override;
-    FairMQMessagePtr CreateMessage(const size_t size) const override;
-    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const override;
-    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) const override;
+    FairMQMessagePtr CreateMessage() override;
+    FairMQMessagePtr CreateMessage(const size_t size) override;
+    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override;
+    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override;
 
     FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) const override;
 
     FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override;
-    FairMQPollerPtr CreatePoller(const std::vector<const FairMQChannel*>& channels) const override;
+    FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override;
     FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override;
-    FairMQPollerPtr CreatePoller(const FairMQSocket& cmdSocket, const FairMQSocket& dataSocket) const override;
 
     FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback) const override;
 
@@ -52,6 +51,7 @@ class FairMQTransportFactoryZMQ : public FairMQTransportFactory
 
     void Interrupt() override { FairMQSocketZMQ::Interrupt(); }
     void Resume() override { FairMQSocketZMQ::Resume(); }
+    void Reset() override {}
 
   private:
     static fair::mq::Transport fTransportType;

fairmq/zeromq/FairMQUnmanagedRegionZMQ.h

@@ -13,7 +13,7 @@
 
 #include <cstddef> // size_t
 
-class FairMQUnmanagedRegionZMQ : public FairMQUnmanagedRegion
+class FairMQUnmanagedRegionZMQ final : public FairMQUnmanagedRegion
 {
     friend class FairMQSocketZMQ;
     friend class FairMQMessageZMQ;

test/CMakeLists.txt

@@ -15,19 +15,19 @@ include(GTestHelper)
 add_testhelper(runTestDevice
     SOURCES
     helper/runTestDevice.cxx
-    helper/devices/TestPairLeft.cxx
-    helper/devices/TestPairRight.cxx
-    helper/devices/TestPollIn.cxx
-    helper/devices/TestPollOut.cxx
-    helper/devices/TestPub.cxx
-    helper/devices/TestPull.cxx
-    helper/devices/TestPush.cxx
-    helper/devices/TestRep.cxx
-    helper/devices/TestReq.cxx
-    helper/devices/TestSub.cxx
-    helper/devices/TestTransferTimeout.cxx
-    helper/devices/TestWaitFor.cxx
-    helper/devices/TestExceptions.cxx
+    helper/devices/TestPairLeft.h
+    helper/devices/TestPairRight.h
+    helper/devices/TestPollIn.h
+    helper/devices/TestPollOut.h
+    helper/devices/TestPub.h
+    helper/devices/TestPull.h
+    helper/devices/TestPush.h
+    helper/devices/TestRep.h
+    helper/devices/TestReq.h
+    helper/devices/TestSub.h
+    helper/devices/TestTransferTimeout.h
+    helper/devices/TestWaitFor.h
+    helper/devices/TestExceptions.h
 
     LINKS FairMQ
 )
@@ -202,11 +202,13 @@ add_testsuite(FairMQ.Transport
     SOURCES
     ${CMAKE_CURRENT_BINARY_DIR}/runner.cxx
     transport/_transfer_timeout.cxx
+    transport/_options.cxx
 
     LINKS FairMQ
     INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}
              ${CMAKE_CURRENT_BINARY_DIR}
     TIMEOUT 10
+    ${definitions}
 )
 
 add_testsuite(FairMQ.Poller
@@ -218,4 +220,16 @@ add_testsuite(FairMQ.Poller
     INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}
              ${CMAKE_CURRENT_BINARY_DIR}
     TIMEOUT 10
+    ${definitions}
 )
+
+add_testsuite(FairMQ.MemoryResources
+    SOURCES
+    memory_resources/runner.cxx
+    memory_resources/_memory_resources.cxx
+
+    LINKS FairMQ
+    INCLUDES ${CMAKE_CURRENT_BINARY_DIR}
+    TIMEOUT 10
+)
+

test/device/TestReceiver.h

@@ -35,11 +35,6 @@ class Receiver : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto msg = FairMQMessagePtr{NewMessage()};

test/device/TestSender.h

@@ -35,11 +35,6 @@ class Sender : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto msg = FairMQMessagePtr{NewMessage()};

test/helper/devices/TestExceptions.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_EXCEPTIONS_H
+#define FAIR_MQ_TEST_EXCEPTIONS_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 
@@ -19,7 +22,7 @@ namespace mq
 namespace test
 {
 
-class TestExceptions : public FairMQDevice
+class Exceptions : public FairMQDevice
 {
   public:
     auto Init() -> void override
@@ -82,3 +85,5 @@ class TestExceptions : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_EXCEPTIONS_H */

test/helper/devices/TestPairLeft.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_PAIRLEFT_H
+#define FAIR_MQ_TEST_PAIRLEFT_H
+
 #include <FairMQDevice.h>
 
 #include <cstddef>
@@ -26,11 +29,6 @@ class PairLeft : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         int counter{0};
@@ -65,3 +63,5 @@ class PairLeft : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_PAIRLEFT_H */

test/helper/devices/TestPairRight.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_PAIRRIGHT_H
+#define FAIR_MQ_TEST_PAIRRIGHT_H
+
 #include <FairMQDevice.h>
 #include <cstddef>
 #include <string>
@@ -26,11 +29,6 @@ class PairRight : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         int counter{0};
@@ -45,7 +43,7 @@ class PairRight : public FairMQDevice
         auto msg4(NewMessageFor("data", 0));
         if (Send(msg4, "data") >= 0) counter++;
         if (counter == 4) LOG(info) << "Simple empty message ping pong successfull";
-        
+
         // Simple message with short text data
         auto msg5(NewMessageFor("data", 0));
         auto ret = Receive(msg5, "data");
@@ -66,3 +64,5 @@ class PairRight : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_PAIRRIGHT_H */

test/helper/devices/TestPollIn.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_POLLIN_H
+#define FAIR_MQ_TEST_POLLIN_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 #include <options/FairMQProgOptions.h>
@@ -33,11 +36,6 @@ class PollIn : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto InitTask() -> void override
     {
         fPollType = fConfig->GetValue<int>("poll-type");
@@ -45,7 +43,7 @@ class PollIn : public FairMQDevice
 
     auto Run() -> void override
     {
-        vector<const FairMQChannel*> chans;
+        vector<FairMQChannel*> chans;
 
         chans.push_back(&fChannels.at("data1").at(0));
         chans.push_back(&fChannels.at("data2").at(0));
@@ -132,3 +130,5 @@ class PollIn : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_POLLIN_H */

test/helper/devices/TestPollOut.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_POLLOUT_H
+#define FAIR_MQ_TEST_POLLOUT_H
+
 #include <FairMQDevice.h>
 #include <thread>
 
@@ -24,11 +27,6 @@ class PollOut : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto msg1 = FairMQMessagePtr{NewMessage()};
@@ -41,3 +39,5 @@ class PollOut : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_POLLOUT_H */

test/helper/devices/TestPub.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_PUB_H
+#define FAIR_MQ_TEST_PUB_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 #include <chrono>
@@ -25,11 +28,6 @@ class Pub : public FairMQDevice
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
-    
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
 
     auto Run() -> void override
     {
@@ -75,3 +73,5 @@ class Pub : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_PUB_H */

test/helper/devices/TestPull.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_PULL_H
+#define FAIR_MQ_TEST_PULL_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 #include <thread>
@@ -27,11 +30,6 @@ class Pull : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto msg = FairMQMessagePtr{NewMessage()};
@@ -46,3 +44,5 @@ class Pull : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_PULL_H */

test/helper/devices/TestPush.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_PUSH_H
+#define FAIR_MQ_TEST_PUSH_H
+
 #include <FairMQDevice.h>
 #include <thread>
 
@@ -24,11 +27,6 @@ class Push : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto msg = FairMQMessagePtr{NewMessage()};
@@ -39,3 +37,5 @@ class Push : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_PUSH_H */

test/helper/devices/TestRep.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_REP_H
+#define FAIR_MQ_TEST_REP_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 #include <thread>
@@ -25,11 +28,6 @@ class Rep : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto request1 = FairMQMessagePtr{NewMessage()};
@@ -54,3 +52,5 @@ class Rep : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_REP_H */

test/helper/devices/TestReq.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_REQ_H
+#define FAIR_MQ_TEST_REQ_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 #include <thread>
@@ -25,11 +28,6 @@ class Req : public FairMQDevice
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
     auto Run() -> void override
     {
         auto request = FairMQMessagePtr{NewMessage()};
@@ -46,3 +44,5 @@ class Req : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_REQ_H */

test/helper/devices/TestSub.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_SUB_H
+#define FAIR_MQ_TEST_SUB_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 #include <chrono>
@@ -25,11 +28,6 @@ class Sub : public FairMQDevice
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
-    
-    auto Reset() -> void override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
 
     auto Run() -> void override
     {
@@ -69,3 +67,5 @@ class Sub : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_SUB_H */

test/helper/devices/TestTransferTimeout.cxx

@@ -1,114 +0,0 @@
-/********************************************************************************
- * Copyright (C) 2015-2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-
-#include <FairMQDevice.h>
-#include <FairMQLogger.h>
-
-namespace fair
-{
-namespace mq
-{
-namespace test
-{
-
-class TransferTimeout : public FairMQDevice
-{
-  protected:
-    auto Run() -> void override
-    {
-        bool sendMsgCanceling = false;
-        bool receiveMsgCanceling = false;
-
-        FairMQMessagePtr msg1(NewMessage());
-        FairMQMessagePtr msg2(NewMessage());
-
-        if (Send(msg1, "data-out", 0, 100) == -2)
-        {
-            LOG(info) << "send msg canceled";
-            sendMsgCanceling = true;
-        }
-        else
-        {
-            LOG(error) << "send msg did not cancel";
-        }
-
-        if (Receive(msg2, "data-in", 0, 100) == -2)
-        {
-            LOG(info) << "receive msg canceled";
-            receiveMsgCanceling = true;
-        }
-        else
-        {
-            LOG(error) << "receive msg did not cancel";
-        }
-
-        bool send1PartCanceling = false;
-        bool receive1PartCanceling = false;
-
-        FairMQParts parts1;
-        parts1.AddPart(NewMessage(10));
-        FairMQParts parts2;
-
-        if (Send(parts1, "data-out", 0, 100) == -2)
-        {
-            LOG(info) << "send 1 part canceled";
-            send1PartCanceling = true;
-        }
-        else
-        {
-            LOG(error) << "send 1 part did not cancel";
-        }
-
-        if (Receive(parts2, "data-in", 0, 100) == -2)
-        {
-            LOG(info) << "receive 1 part canceled";
-            receive1PartCanceling = true;
-        }
-        else
-        {
-            LOG(error) << "receive 1 part did not cancel";
-        }
-
-        bool send2PartsCanceling = false;
-        bool receive2PartsCanceling = false;
-
-        FairMQParts parts3;
-        parts3.AddPart(NewMessage(10));
-        parts3.AddPart(NewMessage(10));
-        FairMQParts parts4;
-
-        if (Send(parts3, "data-out", 0, 100) == -2)
-        {
-            LOG(info) << "send 2 parts canceled";
-            send2PartsCanceling = true;
-        }
-        else
-        {
-            LOG(error) << "send 2 parts did not cancel";
-        }
-
-        if (Receive(parts4, "data-in", 0, 100) == -2)
-        {
-            LOG(info) << "receive 2 parts canceled";
-            receive2PartsCanceling = true;
-        }
-        else
-        {
-            LOG(error) << "receive 2 parts did not cancel";
-        }
-
-        if (sendMsgCanceling && receiveMsgCanceling && send1PartCanceling && receive1PartCanceling && send2PartsCanceling && receive2PartsCanceling)
-        {
-            LOG(info) << "Transfer timeout test successfull";
-        }
-    };
-};
-
-} // namespace test
-} // namespace mq
-} // namespace fair

test/helper/devices/TestTransferTimeout.h

@@ -0,0 +1,163 @@
+/********************************************************************************
+ * Copyright (C) 2015-2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_TEST_TRANSFERTIMEOUT_H
+#define FAIR_MQ_TEST_TRANSFERTIMEOUT_H
+
+#include <FairMQDevice.h>
+#include <FairMQLogger.h>
+
+namespace fair
+{
+namespace mq
+{
+namespace test
+{
+
+class TransferTimeout : public FairMQDevice
+{
+  protected:
+    auto Run() -> void override
+    {
+        bool sendMsgCancelingAfter100ms = false;
+        bool receiveMsgCancelingAfter100ms = false;
+
+        bool sendMsgCancelingAfter0ms = false;
+        bool receiveMsgCancelingAfter0ms = false;
+
+        bool send1PartCancelingAfter100ms = false;
+        bool receive1PartCancelingAfter100ms = false;
+
+        bool send1PartCancelingAfter0ms = false;
+        bool receive1PartCancelingAfter0ms = false;
+
+        bool send2PartsCancelingAfter100ms = false;
+        bool receive2PartsCancelingAfter100ms = false;
+
+        bool send2PartsCancelingAfter0ms = false;
+        bool receive2PartsCancelingAfter0ms = false;
+
+        FairMQMessagePtr msg1(NewMessage());
+        FairMQMessagePtr msg2(NewMessage());
+
+        if (Send(msg1, "data-out", 0, 100) == -2) {
+            LOG(info) << "send msg canceled (100ms)";
+            sendMsgCancelingAfter100ms = true;
+        } else {
+            LOG(error) << "send msg did not cancel (100ms)";
+        }
+
+        if (Receive(msg2, "data-in", 0, 100) == -2) {
+            LOG(info) << "receive msg canceled (100ms)";
+            receiveMsgCancelingAfter100ms = true;
+        } else {
+            LOG(error) << "receive msg did not cancel (100ms)";
+        }
+
+        if (Send(msg1, "data-out", 0, 0) == -2) {
+            LOG(info) << "send msg canceled (0ms)";
+            sendMsgCancelingAfter0ms = true;
+        } else {
+            LOG(error) << "send msg did not cancel (0ms)";
+        }
+
+        if (Receive(msg2, "data-in", 0, 0) == -2) {
+            LOG(info) << "receive msg canceled (0ms)";
+            receiveMsgCancelingAfter0ms = true;
+        } else {
+            LOG(error) << "receive msg did not cancel (0ms)";
+        }
+
+        FairMQParts parts1;
+        parts1.AddPart(NewMessage(10));
+        FairMQParts parts2;
+
+        if (Send(parts1, "data-out", 0, 100) == -2) {
+            LOG(info) << "send 1 part canceled (100ms)";
+            send1PartCancelingAfter100ms = true;
+        } else {
+            LOG(error) << "send 1 part did not cancel (100ms)";
+        }
+
+        if (Receive(parts2, "data-in", 0, 100) == -2) {
+            LOG(info) << "receive 1 part canceled (100ms)";
+            receive1PartCancelingAfter100ms = true;
+        } else {
+            LOG(error) << "receive 1 part did not cancel (100ms)";
+        }
+
+        if (Send(parts1, "data-out", 0, 0) == -2) {
+            LOG(info) << "send 1 part canceled (0ms)";
+            send1PartCancelingAfter0ms = true;
+        } else {
+            LOG(error) << "send 1 part did not cancel (0ms)";
+        }
+
+        if (Receive(parts2, "data-in", 0, 0) == -2) {
+            LOG(info) << "receive 1 part canceled (0ms)";
+            receive1PartCancelingAfter0ms = true;
+        } else {
+            LOG(error) << "receive 1 part did not cancel (0ms)";
+        }
+
+        FairMQParts parts3;
+        parts3.AddPart(NewMessage(10));
+        parts3.AddPart(NewMessage(10));
+        FairMQParts parts4;
+
+        if (Send(parts3, "data-out", 0, 100) == -2) {
+            LOG(info) << "send 2 parts canceled (100ms)";
+            send2PartsCancelingAfter100ms = true;
+        } else {
+            LOG(error) << "send 2 parts did not cancel (100ms)";
+        }
+
+        if (Receive(parts4, "data-in", 0, 100) == -2) {
+            LOG(info) << "receive 2 parts canceled (100ms)";
+            receive2PartsCancelingAfter100ms = true;
+        } else {
+            LOG(error) << "receive 2 parts did not cancel (100ms)";
+        }
+
+        if (Send(parts3, "data-out", 0, 0) == -2) {
+            LOG(info) << "send 2 parts canceled (0ms)";
+            send2PartsCancelingAfter0ms = true;
+        } else {
+            LOG(error) << "send 2 parts did not cancel (0ms)";
+        }
+
+        if (Receive(parts4, "data-in", 0, 0) == -2) {
+            LOG(info) << "receive 2 parts canceled (0ms)";
+            receive2PartsCancelingAfter0ms = true;
+        } else {
+            LOG(error) << "receive 2 parts did not cancel (0ms)";
+        }
+
+        if (sendMsgCancelingAfter100ms &&
+            receiveMsgCancelingAfter100ms &&
+            sendMsgCancelingAfter0ms &&
+            receiveMsgCancelingAfter0ms &&
+            send1PartCancelingAfter100ms &&
+            receive1PartCancelingAfter100ms &&
+            send1PartCancelingAfter0ms &&
+            receive1PartCancelingAfter0ms &&
+            send2PartsCancelingAfter100ms &&
+            receive2PartsCancelingAfter100ms &&
+            send2PartsCancelingAfter0ms &&
+            receive2PartsCancelingAfter0ms)
+        {
+            LOG(info) << "Transfer timeout test successfull";
+        }
+    };
+};
+
+} // namespace test
+} // namespace mq
+} // namespace fair
+
+#endif /* FAIR_MQ_TEST_TRANSFERTIMEOUT_H */

test/helper/devices/TestWaitFor.h

@@ -6,6 +6,9 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#ifndef FAIR_MQ_TEST_WAITFOR_H
+#define FAIR_MQ_TEST_WAITFOR_H
+
 #include <FairMQDevice.h>
 #include <FairMQLogger.h>
 
@@ -31,3 +34,5 @@ class TestWaitFor : public FairMQDevice
 } // namespace test
 } // namespace mq
 } // namespace fair
+
+#endif /* FAIR_MQ_TEST_WAITFOR_H */

test/helper/runTestDevice.cxx

@@ -6,19 +6,19 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include "devices/TestPairLeft.cxx"
-#include "devices/TestPairRight.cxx"
-#include "devices/TestPollIn.cxx"
-#include "devices/TestPollOut.cxx"
-#include "devices/TestPub.cxx"
-#include "devices/TestPull.cxx"
-#include "devices/TestPush.cxx"
-#include "devices/TestRep.cxx"
-#include "devices/TestReq.cxx"
-#include "devices/TestSub.cxx"
-#include "devices/TestTransferTimeout.cxx"
-#include "devices/TestWaitFor.cxx"
-#include "devices/TestExceptions.cxx"
+#include "devices/TestPairLeft.h"
+#include "devices/TestPairRight.h"
+#include "devices/TestPollIn.h"
+#include "devices/TestPollOut.h"
+#include "devices/TestPub.h"
+#include "devices/TestPull.h"
+#include "devices/TestPush.h"
+#include "devices/TestRep.h"
+#include "devices/TestReq.h"
+#include "devices/TestSub.h"
+#include "devices/TestTransferTimeout.h"
+#include "devices/TestWaitFor.h"
+#include "devices/TestExceptions.h"
 
 #include <runFairMQDevice.h>
 
@@ -90,7 +90,7 @@ auto getDevice(const FairMQProgOptions& config) -> FairMQDevicePtr
     }
     else if (0 == id.find("exceptions_"))
     {
-        return new TestExceptions;
+        return new Exceptions;
     }
     else
     {

test/memory_resources/_memory_resources.cxx

@@ -0,0 +1,139 @@
+/********************************************************************************
+ *    Copyright (C) 2018 Goethe University Frankfurt                            *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#include <cstring>
+#include <fairmq/FairMQTransportFactory.h>
+#include <fairmq/MemoryResourceTools.h>
+#include <gtest/gtest.h>
+#include <vector>
+
+namespace {
+
+using namespace std;
+using namespace fair::mq;
+using factoryType = std::shared_ptr<FairMQTransportFactory>;
+
+factoryType factoryZMQ = FairMQTransportFactory::CreateTransportFactory("zeromq");
+factoryType factorySHM = FairMQTransportFactory::CreateTransportFactory("shmem");
+
+struct testData
+{
+    int i{1};
+    static int nallocated;
+    static int nallocations;
+    static int ndeallocations;
+    testData()
+    {
+        ++nallocated;
+        ++nallocations;
+    }
+    testData(const testData& in)
+        : i{in.i}
+    {
+        ++nallocated;
+        ++nallocations;
+    }
+    testData(const testData&& in)
+        : i{in.i}
+    {
+        ++nallocated;
+        ++nallocations;
+    }
+    testData(int in)
+        : i{in}
+    {
+        ++nallocated;
+        ++nallocations;
+    }
+    ~testData()
+    {
+        --nallocated;
+        ++ndeallocations;
+    }
+};
+
+int testData::nallocated = 0;
+int testData::nallocations = 0;
+int testData::ndeallocations = 0;
+
+auto allocZMQ = factoryZMQ -> GetMemoryResource();
+auto allocSHM = factorySHM -> GetMemoryResource();
+
+TEST(MemoryResources, transportallocatormap_test)
+{
+    EXPECT_TRUE(allocZMQ != nullptr && allocSHM != allocZMQ);
+    auto _tmp = factoryZMQ->GetMemoryResource();
+    EXPECT_TRUE(_tmp == allocZMQ);
+}
+
+using namespace fair::mq::pmr;
+
+TEST(MemoryResources, allocator_test)
+{
+    testData::nallocations = 0;
+    testData::ndeallocations = 0;
+
+    {
+        std::vector<testData, polymorphic_allocator<testData>> v(
+            polymorphic_allocator<testData>{allocZMQ});
+        v.reserve(3);
+        EXPECT_TRUE(v.capacity() == 3);
+        EXPECT_TRUE(allocZMQ->getNumberOfMessages() == 1);
+        v.emplace_back(1);
+        v.emplace_back(2);
+        v.emplace_back(3);
+        EXPECT_TRUE((byte*)&(*v.end()) - (byte*)&(*v.begin()) == 3 * sizeof(testData));
+        EXPECT_TRUE(testData::nallocated == 3);
+    }
+    EXPECT_TRUE(testData::nallocated == 0);
+    EXPECT_TRUE(testData::nallocations == testData::ndeallocations);
+}
+
+TEST(MemoryResources, getMessage_test)
+{
+    testData::nallocations = 0;
+    testData::ndeallocations = 0;
+
+    FairMQMessagePtr message{nullptr};
+
+    int* messageArray{nullptr};
+
+    // test message creation on the same channel it was allocated with
+    {
+        std::vector<testData, polymorphic_allocator<testData>> v(
+            polymorphic_allocator<testData>{allocZMQ});
+        v.emplace_back(1);
+        v.emplace_back(2);
+        v.emplace_back(3);
+        void* vectorBeginPtr = &v[0];
+        message = getMessage(std::move(v));
+        EXPECT_TRUE(message != nullptr);
+        EXPECT_TRUE(message->GetData() == vectorBeginPtr);
+    }
+    EXPECT_TRUE(message->GetSize() == 3 * sizeof(testData));
+    messageArray = static_cast<int*>(message->GetData());
+    EXPECT_TRUE(messageArray[0] == 1 && messageArray[1] == 2 && messageArray[2] == 3);
+
+    // test message creation on a different channel than it was allocated with
+    {
+        std::vector<testData, polymorphic_allocator<testData>> v(
+            polymorphic_allocator<testData>{allocZMQ});
+        v.emplace_back(4);
+        v.emplace_back(5);
+        v.emplace_back(6);
+        void* vectorBeginPtr = &v[0];
+        message = getMessage(std::move(v), allocSHM);
+        EXPECT_TRUE(message != nullptr);
+        EXPECT_TRUE(message->GetData() != vectorBeginPtr);
+    }
+    EXPECT_TRUE(message->GetSize() == 3 * sizeof(testData));
+    messageArray = static_cast<int*>(message->GetData());
+    EXPECT_TRUE(messageArray[0] == 4 && messageArray[1] == 5 && messageArray[2] == 6);
+}
+
+}   // namespace

test/memory_resources/runner.cxx

@@ -0,0 +1,19 @@
+/********************************************************************************
+ *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#include <TestEnvironment.h>
+
+#include <gtest/gtest.h>
+
+auto main(int argc, char** argv) -> int
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+    setenv("FAIRMQ_PATH", FAIRMQ_TEST_ENVIRONMENT, 0);
+    return RUN_ALL_TESTS();
+}

test/transport/_options.cxx

@@ -0,0 +1,98 @@
+/********************************************************************************
+ *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#include <gtest/gtest.h>
+#include <FairMQChannel.h>
+#include <FairMQParts.h>
+#include <FairMQLogger.h>
+#include <FairMQTransportFactory.h>
+#include <fairmq/Tools.h>
+#include <options/FairMQProgOptions.h>
+
+#include <algorithm>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <thread>
+
+namespace
+{
+
+using namespace std;
+
+void CheckOldOptionInterface(FairMQChannel& channel, const string& option, const string& transport)
+{
+    int value = 500;
+    channel.GetSocket().SetOption(option, &value, sizeof(value));
+    value = 0;
+    size_t valueSize = sizeof(value);
+    channel.GetSocket().GetOption(option, &value, &valueSize);
+    if (transport == "nanomsg" && (option == "snd-hwm" || option == "rcv-hwm")) {
+        ASSERT_EQ(value, -1);
+    } else {
+        ASSERT_EQ(value, 500);
+    }
+}
+
+void RunOptionsTest(const string& transport)
+{
+    size_t session{fair::mq::tools::UuidHash()};
+
+    FairMQProgOptions config;
+    config.SetValue<string>("session", to_string(session));
+    auto factory = FairMQTransportFactory::CreateTransportFactory(transport, fair::mq::tools::Uuid(), &config);
+    FairMQChannel channel("Push", "push", factory);
+
+    CheckOldOptionInterface(channel, "linger", transport);
+    CheckOldOptionInterface(channel, "snd-hwm", transport);
+    CheckOldOptionInterface(channel, "rcv-hwm", transport);
+    CheckOldOptionInterface(channel, "snd-size", transport);
+    CheckOldOptionInterface(channel, "rcv-size", transport);
+
+    channel.GetSocket().SetLinger(300);
+    ASSERT_EQ(channel.GetSocket().GetLinger(), 300);
+
+    channel.GetSocket().SetSndBufSize(500);
+    if (transport == "nanomsg") { // nanomsg doesn't use this option and the getter always returns -1
+        ASSERT_EQ(channel.GetSocket().GetSndBufSize(), -1);
+    } else {
+        ASSERT_EQ(channel.GetSocket().GetSndBufSize(), 500);
+    }
+
+    channel.GetSocket().SetRcvBufSize(500);
+    if (transport == "nanomsg") { // nanomsg doesn't use this option and the getter always returns -1
+        ASSERT_EQ(channel.GetSocket().GetRcvBufSize(), -1);
+    } else {
+        ASSERT_EQ(channel.GetSocket().GetRcvBufSize(), 500);
+    }
+
+    channel.GetSocket().SetSndKernelSize(8000);
+    ASSERT_EQ(channel.GetSocket().GetSndKernelSize(), 8000);
+
+    channel.GetSocket().SetRcvKernelSize(8000);
+    ASSERT_EQ(channel.GetSocket().GetRcvKernelSize(), 8000);
+}
+
+TEST(Options, ZeroMQ)
+{
+    RunOptionsTest("zeromq");
+}
+
+TEST(Options, shmem)
+{
+    RunOptionsTest("shmem");
+}
+
+#ifdef BUILD_NANOMSG_TRANSPORT
+TEST(Options, nanomsg)
+{
+    RunOptionsTest("nanomsg");
+}
+#endif /* BUILD_NANOMSG_TRANSPORT */
+
+} // namespace