CMake: Support DDS 2.4

reduces boilerplate

CMakeLists.txt

@@ -7,13 +7,12 @@
 ################################################################################
 
 cmake_minimum_required(VERSION 3.9.4 FATAL_ERROR)
-
+cmake_policy(VERSION 3.9...3.15)
 
 # Project ######################################################################
 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
 include(FairMQLib)
 
-set_fairmq_cmake_policies()
 get_git_version()
 
 project(FairMQ VERSION ${PROJECT_VERSION} LANGUAGES CXX)
@@ -49,8 +48,12 @@ 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
   )
+  # Normalize Boost version
+  if(CMAKE_VERSION VERSION_LESS 3.15)
+    set(Boost_VERSION "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+  endif()
   find_package2(PUBLIC FairLogger VERSION 1.2.0 REQUIRED)
   find_package2(PRIVATE ZeroMQ VERSION 4.1.5 REQUIRED)
 endif()
@@ -67,7 +70,7 @@ if(BUILD_OFI_TRANSPORT)
 endif()
 
 if(BUILD_DDS_PLUGIN)
-  find_package2(PRIVATE DDS VERSION 2.0 REQUIRED)
+  find_package2(PRIVATE DDS VERSION 2.2 REQUIRED)
 endif()
 
 if(BUILD_TESTING)
@@ -212,7 +215,11 @@ if(PROJECT_PACKAGE_DEPENDENCIES)
       pad("${version_str}${version_req_str}" 25 " " version_padded COLOR 1)
     endif()
     if(${dep} STREQUAL FairLogger)
-      set(prefix ${FairLogger_ROOT})
+      if(FairLogger_PREFIX)
+       set(prefix ${FairLogger_PREFIX})
+      else()
+        set(prefix ${FairLogger_ROOT})
+      endif()
     elseif(${dep} STREQUAL GTest)
       get_filename_component(prefix ${GTEST_INCLUDE_DIRS}/.. ABSOLUTE)
     elseif(${dep} STREQUAL msgpack)
@@ -220,6 +227,9 @@ if(PROJECT_PACKAGE_DEPENDENCIES)
       get_filename_component(prefix ${msgpack_include}/.. ABSOLUTE)
     elseif(${dep} STREQUAL OFI)
       get_filename_component(prefix ${${dep}_INCLUDE_DIRS}/.. ABSOLUTE)
+    elseif(${dep} STREQUAL nanomsg)
+      get_target_property(nn_include nanomsg INTERFACE_INCLUDE_DIRECTORIES)
+      get_filename_component(prefix ${nn_include}/.. ABSOLUTE)
     elseif(${dep} STREQUAL Doxygen)
       get_target_property(doxygen_bin Doxygen::doxygen INTERFACE_LOCATION)
       get_filename_component(prefix ${doxygen_bin} DIRECTORY)

CONTRIBUTORS

@@ -4,6 +4,7 @@ Eulisse, Giulio
 Karabowicz, Radoslaw
 Kretz, Matthias <kretz@kde.org>
 Krzewicki, Mikolaj 
+Mrnjavac, Teo <teo.m@cern.ch>
 Neskovic, Gvozden
 Richter, Matthias
 Uhlig, Florian

FairMQTest.cmake

@@ -19,7 +19,7 @@ Set(BUILD_COMMAND "make")
 Set(CTEST_BUILD_COMMAND "${BUILD_COMMAND} -j$ENV{number_of_processors}")
 
 String(TOUPPER $ENV{ctest_model} _Model)
-Set(configure_options "-DCMAKE_BUILD_TYPE=${_Model}")
+Set(configure_options "-DCMAKE_BUILD_TYPE=$ENV{ctest_model}")
 
 Set(CTEST_USE_LAUNCHERS 1)
 Set(configure_options "${configure_options};-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}")

Jenkinsfile

@@ -8,6 +8,9 @@ def jobMatrix(String prefix, List specs, Closure callback) {
   def nodes = [:]
   for (spec in specs) {
     def label = specToLabel(spec)
+    def fairsoft = spec.fairsoft
+    def os = spec.os
+    def compiler = spec.compiler
     nodes["${prefix}/${label}"] = {
       node(label) {
         githubNotify(context: "${prefix}/${label}", description: 'Building ...', status: 'PENDING')
@@ -15,12 +18,31 @@ def jobMatrix(String prefix, List specs, Closure callback) {
           deleteDir()
           checkout scm
 
+          sh """\
+            echo "export SIMPATH=\${SIMPATH_PREFIX}${fairsoft}" >> Dart.cfg
+            echo "export FAIRSOFT_VERSION=${fairsoft}" >> Dart.cfg
+          """
+          if (os =~ /Debian/ && compiler =~ /gcc8/) {
+            sh '''\
+              echo "source /etc/profile.d/modules.sh" >> Dart.cfg
+              echo "module use /cvmfs/it.gsi.de/modulefiles" >> Dart.cfg
+              echo "module load compiler/gcc/8" >> Dart.cfg
+            '''
+          }
+          if (os =~ /MacOS/) {
+            sh "echo \"export EXTRA_FLAGS='-DCMAKE_CXX_COMPILER=clang++'\" >> Dart.cfg"
+          } else {
+            sh "echo \"export EXTRA_FLAGS='-DCMAKE_CXX_COMPILER=g++'\" >> Dart.cfg"
+          }
+
           sh '''\
             echo "export BUILDDIR=$PWD/build" >> Dart.cfg
             echo "export SOURCEDIR=$PWD" >> Dart.cfg
-            echo "export PATH=$SIMPATH/bin:$PATH" >> Dart.cfg
+            echo "export PATH=\\\$SIMPATH/bin:\\\$PATH" >> Dart.cfg
             echo "export GIT_BRANCH=$JOB_BASE_NAME" >> Dart.cfg
+            echo "echo \\\$PATH" >> Dart.cfg
           '''
+          sh 'cat Dart.cfg'
 
           callback.call(spec, label)
 
@@ -44,14 +66,14 @@ pipeline{
       steps{
         script {
           def build_jobs = jobMatrix('alfa-ci/build', [
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc4.9',         fairsoft: 'may18'],
-            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM9.0.0', fairsoft: 'may18'],
+            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc8.1.0',          fairsoft: 'fairmq_dev'],
+            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM10.0.0', fairsoft: 'fairmq_dev'],
           ]) { spec, label ->
             sh './Dart.sh alfa_ci Dart.cfg'
           }
 
           def profile_jobs = jobMatrix('alfa-ci/codecov', [
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc4.9',         fairsoft: 'may18'],
+            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc8.1.0',          fairsoft: 'fairmq_dev'],
           ]) { spec, label ->
             withCredentials([string(credentialsId: 'fairmq_codecov_token', variable: 'CODECOV_TOKEN')]) {
               sh './Dart.sh codecov Dart.cfg'

Jenkinsfile.nightly

@@ -8,12 +8,40 @@ def buildMatrix(List specs, Closure callback) {
   def nodes = [:]
   for (spec in specs) {
     def label = specToLabel(spec)
+    def fairsoft = spec.fairsoft
+    def os = spec.os
+    def compiler = spec.compiler
     nodes[label] = {
       node(label) {
         try {
           deleteDir()
           checkout scm
 
+          sh """\
+            echo "export SIMPATH=\${SIMPATH_PREFIX}${fairsoft}" >> Dart.cfg
+            echo "export FAIRSOFT_VERSION=${fairsoft}" >> Dart.cfg
+          """
+          if (os =~ /Debian/ && compiler =~ /gcc8/) {
+            sh '''\
+              echo "source /etc/profile.d/modules.sh" >> Dart.cfg
+              echo "module use /cvmfs/it.gsi.de/modulefiles" >> Dart.cfg
+              echo "module load compiler/gcc/8" >> Dart.cfg
+            '''
+          }
+          if (os =~ /MacOS/) {
+            sh "echo \"export EXTRA_FLAGS='-DCMAKE_CXX_COMPILER=clang++'\" >> Dart.cfg"
+          } else {
+            sh "echo \"export EXTRA_FLAGS='-DCMAKE_CXX_COMPILER=g++'\" >> Dart.cfg"
+          }
+          sh '''\
+            echo "export BUILDDIR=$PWD/build" >> Dart.cfg
+            echo "export SOURCEDIR=$PWD" >> Dart.cfg
+            echo "export PATH=\\\$SIMPATH/bin:\\\$PATH" >> Dart.cfg
+            echo "export GIT_BRANCH=dev" >> Dart.cfg
+            echo "echo \\\$PATH" >> Dart.cfg
+          '''
+          sh 'cat Dart.cfg'
+
           callback.call(spec, label)
 
           deleteDir()
@@ -35,16 +63,9 @@ pipeline{
       steps{
         script {
           parallel(buildMatrix([
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc4.9',         fairsoft: 'may18'],
-            [os: 'MacOS10.11', arch: 'x86_64', compiler: 'AppleLLVM8.0.0', fairsoft: 'may18'],
-            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM9.0.0', fairsoft: 'may18'],
+            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc8.1.0',         fairsoft: 'fairmq_dev'],
+            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM10.0.0',  fairsoft: 'fairmq_dev'],
           ]) { spec, label ->
-            sh '''\
-              echo "export BUILDDIR=$PWD/build" >> Dart.cfg
-              echo "export SOURCEDIR=$PWD" >> Dart.cfg
-              echo "export PATH=$SIMPATH/bin:$PATH" >> Dart.cfg
-              echo "export GIT_BRANCH=dev" >> Dart.cfg
-            '''
             sh './Dart.sh Nightly Dart.cfg'
             sh './Dart.sh Profile Dart.cfg'
           })

README.md

@@ -1,5 +1,5 @@
 <!-- {#mainpage} -->
-# FairMQ [![license](https://alfa-ci.gsi.de/shields/badge/license-LGPL--3.0-orange.svg)](COPYRIGHT) [![build status](https://alfa-ci.gsi.de/buildStatus/icon?job=FairRootGroup/FairMQ/master)](https://alfa-ci.gsi.de/blue/organizations/jenkins/FairRootGroup%2FFairMQ/branches) [![test coverage master branch](https://codecov.io/gh/FairRootGroup/FairMQ/branch/master/graph/badge.svg)](https://codecov.io/gh/FairRootGroup/FairMQ/branch/master)
+# FairMQ [![license](https://alfa-ci.gsi.de/shields/badge/license-LGPL--3.0-orange.svg)](COPYRIGHT) [![build status](https://alfa-ci.gsi.de/buildStatus/icon?job=FairRootGroup/FairMQ/master)](https://alfa-ci.gsi.de/blue/organizations/jenkins/FairRootGroup%2FFairMQ/branches) [![test coverage master branch](https://codecov.io/gh/FairRootGroup/FairMQ/branch/master/graph/badge.svg)](https://codecov.io/gh/FairRootGroup/FairMQ/branch/master) [![Coverity Badge](https://alfa-ci.gsi.de/shields/coverity/scan/fairrootgroup-fairmq.svg)](https://scan.coverity.com/projects/fairrootgroup-fairmq) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/6b648d95d68d4c4eae833b84f84d299c)](https://www.codacy.com/app/dennisklein/FairMQ?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=FairRootGroup/FairMQ&amp;utm_campaign=Badge_Grade)
 
 C++ Message Queuing Library and Framework
 

cmake/FairMQConfig.cmake.in

@@ -23,6 +23,7 @@ set_and_check(@PROJECT_NAME@_CMAKEMODDIR @PACKAGE_CMAKE_INSTALL_PREFIX@/@PROJECT
 set(@PROJECT_NAME@_CXX_STANDARD_REQUIRED @CMAKE_CXX_STANDARD_REQUIRED@)
 set(@PROJECT_NAME@_CXX_STANDARD @CMAKE_CXX_STANDARD@)
 set(@PROJECT_NAME@_CXX_EXTENSIONS @CMAKE_CXX_EXTENSIONS@)
+set(@PROJECT_NAME@_VERSION_HOTFIX @PROJECT_VERSION_HOTFIX@)
 
 ### Import cmake modules
 set(CMAKE_MODULE_PATH ${@PROJECT_NAME@_CMAKEMODDIR} ${CMAKE_MODULE_PATH})

cmake/FairMQLib.cmake

@@ -29,25 +29,6 @@ if(NOT WIN32 AND NOT DISABLE_COLOR)
   set(BWhite   "${Esc}[1;37m")
 endif()
 
-# set_fairmq_cmake_policies()
-#
-# Sets CMake policies.
-macro(set_fairmq_cmake_policies)
-  # Find more details to each policy with cmake --help-policy CMPXXXX
-  foreach(policy
-    CMP0025 # Compiler id for Apple Clang is now AppleClang.
-    CMP0028 # Double colon in target name means ALIAS or IMPORTED target.
-    CMP0042 # MACOSX_RPATH is enabled by default.
-    CMP0048 # The ``project()`` command manages VERSION variables.
-    CMP0054 # Only interpret ``if()`` arguments as variables or keywords when unquoted.
-  )
-    if(POLICY ${policy})
-      cmake_policy(SET ${policy} NEW)
-    endif()
-  endforeach()
-endmacro()
-
-
 find_package(Git)
 # get_git_version([DEFAULT_VERSION version] [DEFAULT_DATE date] [OUTVAR_PREFIX prefix])
 #
@@ -123,8 +104,14 @@ macro(set_fairmq_defaults)
   endif()
   set(CMAKE_CXX_EXTENSIONS OFF)
 
+  if(NOT BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS ON CACHE BOOL "Whether to build shared libraries or static archives")
+  endif()
+
   # Set -fPIC as default for all library types
-  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  if(NOT CMAKE_POSITION_INDEPENDENT_CODE)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
 
   # Generate compile_commands.json file (https://clang.llvm.org/docs/JSONCompilationDatabase.html)
   set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -158,12 +145,13 @@ macro(set_fairmq_defaults)
   set(PROJECT_EXPORT_SET ${PROJECT_NAME}Targets)
 
   # Configure build types
-  set(CMAKE_CONFIGURATION_TYPES "Debug" "Release" "RelWithDebInfo" "Nightly" "Profile" "AdressSan" "ThreadSan")
+  set(CMAKE_CONFIGURATION_TYPES "Debug" "Release" "RelWithDebInfo" "Nightly" "Profile" "Experimental" "AdressSan" "ThreadSan")
   set(CMAKE_CXX_FLAGS_DEBUG          "-g -Wshadow -Wall -Wextra")
   set(CMAKE_CXX_FLAGS_RELEASE        "-O2 -DNDEBUG")
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -Wshadow -Wall -Wextra -DNDEBUG")
   set(CMAKE_CXX_FLAGS_NIGHTLY        "-O2 -g -Wshadow -Wall -Wextra")
   set(CMAKE_CXX_FLAGS_PROFILE        "-g3 -Wshadow -Wall -Wextra -fno-inline -ftest-coverage -fprofile-arcs")
+  set(CMAKE_CXX_FLAGS_EXPERIMENTAL   "-O2 -g -Wshadow -Wall -Wextra -DNDEBUG")
   set(CMAKE_CXX_FLAGS_ADRESSSAN      "-O2 -g -Wshadow -Wall -Wextra -fsanitize=address -fno-omit-frame-pointer")
   set(CMAKE_CXX_FLAGS_THREADSAN      "-O2 -g -Wshadow -Wall -Wextra -fsanitize=thread")
 
@@ -174,6 +162,12 @@ macro(set_fairmq_defaults)
     # Rationale in https://github.com/ninja-build/ninja/issues/814
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always")
   endif()
+
+  if(NOT PROJECT_VERSION_TWEAK)
+    set(PROJECT_VERSION_HOTFIX 0)
+  else()
+    set(PROJECT_VERSION_HOTFIX ${PROJECT_VERSION_TWEAK})
+  endif()
 endmacro()
 
 function(join VALUES GLUE OUTPUT)

cmake/FindDDS.cmake

@@ -11,6 +11,13 @@ find_path(DDS_INCLUDE_DIR
   HINTS ${DDS_ROOT} $ENV{DDS_ROOT}
   PATH_SUFFIXES include
 )
+if(NOT DDS_INCLUDE_DIR)
+find_path(DDS_INCLUDE_DIR
+  NAMES dds_intercom.h
+  HINTS ${DDS_ROOT} $ENV{DDS_ROOT}
+  PATH_SUFFIXES include/DDS
+)
+endif()
 
 find_path(DDS_LIBRARY_DIR
   NAMES libdds_intercom_lib.dylib libdds_intercom_lib.so

examples/1-1/test-ex-1-1.sh.in

@@ -8,6 +8,8 @@ if [[ $1 =~ ^[a-z]+$ ]]; then
     transport=$1
 fi
 
+SESSION="$(@CMAKE_BINARY_DIR@/fairmq/fairmq-uuid-gen -h)"
+
 # setup a trap to kill everything if the test fails/timeouts
 trap 'kill -TERM $SAMPLER_PID; kill -TERM $SINK_PID; wait $SAMPLER_PID; wait $SINK_PID;' TERM
 
@@ -16,6 +18,7 @@ SAMPLER+=" --id sampler1"
 SAMPLER+=" --rate 1"
 SAMPLER+=" --transport $transport"
 SAMPLER+=" --verbosity veryhigh"
+SAMPLER+=" --session $SESSION"
 SAMPLER+=" --control static --color false"
 SAMPLER+=" --max-iterations 1"
 SAMPLER+=" --channel-config name=data,type=push,method=bind,address=tcp://*:5555,rateLogging=0"
@@ -26,6 +29,7 @@ SINK="fairmq-ex-1-1-sink"
 SINK+=" --id sink1"
 SINK+=" --transport $transport"
 SINK+=" --verbosity veryhigh"
+SINK+=" --session $SESSION"
 SINK+=" --control static --color false"
 SINK+=" --max-iterations 1"
 SINK+=" --channel-config name=data,type=pull,method=connect,address=tcp://localhost:5555,rateLogging=0"

examples/1-n-1/test-ex-1-n-1.sh.in

@@ -9,6 +9,7 @@ if [[ $1 =~ ^[a-z]+$ ]]; then
 fi
 
 ex2config="@CMAKE_CURRENT_BINARY_DIR@/ex-1-n-1.json"
+SESSION="$(@CMAKE_BINARY_DIR@/fairmq/fairmq-uuid-gen -h)"
 
 # setup a trap to kill everything if the test fails/timeouts
 trap 'kill -TERM $SAMPLER_PID; kill -TERM $SINK_PID; kill -TERM $PROCESSOR1_PID; kill -TERM $PROCESSOR2_PID; wait $SAMPLER_PID; wait $SINK_PID; wait $PROCESSOR1_PID; wait $PROCESSOR2_PID;' TERM
@@ -17,6 +18,7 @@ SAMPLER="fairmq-ex-1-n-1-sampler"
 SAMPLER+=" --id sampler1"
 SAMPLER+=" --transport $transport"
 SAMPLER+=" --verbosity veryhigh"
+SAMPLER+=" --session $SESSION"
 SAMPLER+=" --control static --color false"
 SAMPLER+=" --max-iterations 2"
 SAMPLER+=" --mq-config $ex2config"
@@ -27,6 +29,7 @@ PROCESSOR1="fairmq-ex-1-n-1-processor"
 PROCESSOR1+=" --id processor1"
 PROCESSOR1+=" --transport $transport"
 PROCESSOR1+=" --verbosity veryhigh"
+PROCESSOR1+=" --session $SESSION"
 PROCESSOR1+=" --control static --color false"
 PROCESSOR1+=" --mq-config $ex2config"
 PROCESSOR1+=" --config-key processor"
@@ -37,6 +40,7 @@ PROCESSOR2="fairmq-ex-1-n-1-processor"
 PROCESSOR2+=" --id processor2"
 PROCESSOR2+=" --transport $transport"
 PROCESSOR2+=" --verbosity veryhigh"
+PROCESSOR2+=" --session $SESSION"
 PROCESSOR2+=" --control static --color false"
 PROCESSOR2+=" --mq-config $ex2config"
 PROCESSOR2+=" --config-key processor"
@@ -47,6 +51,7 @@ SINK="fairmq-ex-1-n-1-sink"
 SINK+=" --id sink1"
 SINK+=" --transport $transport"
 SINK+=" --verbosity veryhigh"
+SINK+=" --session $SESSION"
 SINK+=" --control static --color false"
 SINK+=" --max-iterations 2"
 SINK+=" --mq-config $ex2config"

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/copypush/test-ex-copypush.sh.in

@@ -8,6 +8,8 @@ if [[ $1 =~ ^[a-z]+$ ]]; then
     transport=$1
 fi
 
+SESSION="$(@CMAKE_BINARY_DIR@/fairmq/fairmq-uuid-gen -h)"
+
 # setup a trap to kill everything if the test fails/timeouts
 trap 'kill -TERM $SAMPLER_PID; kill -TERM $SINK1_PID; kill -TERM $SINK2_PID; wait $SAMPLER_PID; wait $SINK1_PID; wait $SINK2_PID;' TERM
 
@@ -15,6 +17,7 @@ SAMPLER="fairmq-ex-copypush-sampler"
 SAMPLER+=" --id sampler1"
 SAMPLER+=" --transport $transport"
 SAMPLER+=" --verbosity veryhigh"
+SAMPLER+=" --session $SESSION"
 SAMPLER+=" --control static --color false"
 SAMPLER+=" --max-iterations 1"
 SAMPLER+=" --channel-config name=data,type=push,method=bind,rateLogging=0,address=tcp://*:5555,address=tcp://*:5556"
@@ -25,6 +28,7 @@ SINK1="fairmq-ex-copypush-sink"
 SINK1+=" --id sink1"
 SINK1+=" --transport $transport"
 SINK1+=" --verbosity veryhigh"
+SINK1+=" --session $SESSION"
 SINK1+=" --control static --color false"
 SINK1+=" --max-iterations 1"
 SINK1+=" --channel-config name=data,type=pull,method=connect,rateLogging=0,address=tcp://localhost:5555"
@@ -35,6 +39,7 @@ SINK2="fairmq-ex-copypush-sink"
 SINK2+=" --id sink2"
 SINK2+=" --transport $transport"
 SINK2+=" --verbosity veryhigh"
+SINK2+=" --session $SESSION"
 SINK2+=" --control static --color false"
 SINK2+=" --max-iterations 1"
 SINK2+=" --channel-config name=data,type=pull,method=connect,rateLogging=0,address=tcp://localhost:5556"

examples/dds/README.md

@@ -47,7 +47,7 @@ The configuration of the channel connection addresses is done by the DDS plugin
 
 Note that the attributes `value` contain a different value.
 
-##### 4. Start DDS server.
+##### 4. Start DDS session.
 
 First you need to initialize DDS environment:
 
@@ -55,10 +55,10 @@ First you need to initialize DDS environment:
 source DDS_env.sh  # this script is located in the DDS installation directory
 ```
 
-The DDS server is started with:
+The DDS session is started with:
 
 ```bash
-dds-server start -s
+dds-session start
 ```
 
 ##### 5. Submit DDS Agents (configured in the hosts file).
@@ -91,7 +91,7 @@ A simple utility (fairmq-dds-command-ui) is included with FairMQ to send command
 
 To see it in action, start the fairmq-dds-command-ui while the topology is running. Run the utility with `-h` to see everything that it can do.
 
-The utility requires a session parameter to connect to appropriate DDS session. The session value is given when starting dds-server.
+The utility requires a session parameter to connect to appropriate DDS session. The session value is given when starting dds-session.
 
 By default the command UI sends commands to all tasks. This can be further refined by giving a specific topology path via `-p` argument.
 Given our topology file, here are some examples of valid paths:
@@ -108,15 +108,15 @@ Given our topology file, here are some examples of valid paths:
 ./fairmq/plugins/DDS/fairmq-dds-command-ui -s 937ffbca-b524-44d8-9898-1d69aedc3751 -c c -p main/ProcessorGroup/Processor_9
 ```
 
-##### 9. Stop DDS server/topology.
+##### 9. Stop DDS session/topology.
 
 The execution of tasks can be stopped with:
 ```bash
 dds-topology --stop
 ```
-Or by stopping the DDS server:
+Or by stopping the DDS session:
 ```bash
-dds-server stop
+dds-session stop
 ```
 
 For general DDS documentation please refer to [DDS Website](http://dds.gsi.de/).

examples/multipart/test-ex-multipart.sh.in

@@ -8,6 +8,8 @@ if [[ $1 =~ ^[a-z]+$ ]]; then
     transport=$1
 fi
 
+SESSION="$(@CMAKE_BINARY_DIR@/fairmq/fairmq-uuid-gen -h)"
+
 # setup a trap to kill everything if the test fails/timeouts
 trap 'kill -TERM $SAMPLER_PID; kill -TERM $SINK_PID; wait $SAMPLER_PID; wait $SINK_PID;' TERM
 
@@ -15,6 +17,7 @@ SAMPLER="fairmq-ex-multipart-sampler"
 SAMPLER+=" --id sampler1"
 SAMPLER+=" --transport $transport"
 SAMPLER+=" --verbosity veryhigh"
+SAMPLER+=" --session $SESSION"
 SAMPLER+=" --max-iterations 1"
 SAMPLER+=" --control static --color false"
 SAMPLER+=" --channel-config name=data,type=push,method=connect,rateLogging=0,address=tcp://127.0.0.1:5555"
@@ -25,6 +28,7 @@ SINK="fairmq-ex-multipart-sink"
 SINK+=" --id sink1"
 SINK+=" --transport $transport"
 SINK+=" --verbosity veryhigh"
+SINK+=" --session $SESSION"
 SINK+=" --control static --color false"
 SINK+=" --channel-config name=data,type=pull,method=bind,rateLogging=0,address=tcp://127.0.0.1:5555"
 @CMAKE_CURRENT_BINARY_DIR@/$SINK &

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 &

examples/req-rep/test-ex-req-rep.sh.in

@@ -8,6 +8,8 @@ if [[ $1 =~ ^[a-z]+$ ]]; then
     transport=$1
 fi
 
+SESSION="$(@CMAKE_BINARY_DIR@/fairmq/fairmq-uuid-gen -h)"
+
 # setup a trap to kill everything if the test fails/timeouts
 trap 'kill -TERM $CLIENT_PID; kill -TERM $SERVER_PID; wait $CLIENT_PID; wait $SERVER_PID;' TERM
 
@@ -15,6 +17,7 @@ CLIENT="fairmq-ex-req-rep-client"
 CLIENT+=" --id client"
 CLIENT+=" --transport $transport"
 CLIENT+=" --verbosity veryhigh"
+CLIENT+=" --session $SESSION"
 CLIENT+=" --control static --color false"
 CLIENT+=" --max-iterations 1"
 CLIENT+=" --channel-config name=data,type=req,method=connect,rateLogging=0,address=tcp://127.0.0.1:5005"
@@ -25,6 +28,7 @@ SERVER="fairmq-ex-req-rep-server"
 SERVER+=" --id server"
 SERVER+=" --transport $transport"
 SERVER+=" --verbosity veryhigh"
+SERVER+=" --session $SESSION"
 SERVER+=" --control static --color false"
 SERVER+=" --max-iterations 1"
 SERVER+=" --channel-config name=data,type=rep,method=bind,rateLogging=0,address=tcp://127.0.0.1:5005"

fairmq/CMakeLists.txt

@@ -28,7 +28,6 @@ endif()
 ##################
 # subdirectories #
 ##################
-# add_subdirectory(shmem/prototype)
 if(BUILD_OFI_TRANSPORT)
   add_subdirectory(ofi)
 endif()
@@ -38,146 +37,147 @@ endif()
 # libFairMQ header files #
 ##########################
 set(FAIRMQ_PUBLIC_HEADER_FILES
-    DeviceRunner.h
-    EventManager.h
-    FairMQChannel.h
-    FairMQDevice.h
-    FairMQLogger.h
-    FairMQMessage.h
-    FairMQParts.h
-    FairMQPoller.h
-    FairMQUnmanagedRegion.h
-    FairMQSocket.h
-    FairMQStateMachine.h
-    FairMQTransportFactory.h
-    Tools.h
-    Transports.h
-    options/FairMQProgOptions.h
-    options/FairProgOptions.h
-    Plugin.h
-    PluginManager.h
-    PluginServices.h
-    runFairMQDevice.h
-    tools/CppSTL.h
-    tools/Network.h
-    tools/Process.h
-    tools/RateLimit.h
-    tools/Strings.h
-    tools/Unique.h
-    tools/Version.h
+  DeviceRunner.h
+  EventManager.h
+  FairMQChannel.h
+  FairMQDevice.h
+  FairMQLogger.h
+  FairMQMessage.h
+  FairMQParts.h
+  FairMQPoller.h
+  FairMQUnmanagedRegion.h
+  FairMQSocket.h
+  FairMQStateMachine.h
+  FairMQTransportFactory.h
+  MemoryResources.h
+  MemoryResourceTools.h
+  Tools.h
+  Transports.h
+  options/FairMQProgOptions.h
+  options/FairProgOptions.h
+  Plugin.h
+  PluginManager.h
+  PluginServices.h
+  runFairMQDevice.h
+  tools/CppSTL.h
+  tools/Network.h
+  tools/Process.h
+  tools/RateLimit.h
+  tools/Strings.h
+  tools/Unique.h
+  tools/Version.h
 )
 
 set(FAIRMQ_PRIVATE_HEADER_FILES
-    devices/FairMQBenchmarkSampler.h
-    devices/FairMQMerger.h
-    devices/FairMQMultiplier.h
-    devices/FairMQProxy.h
-    devices/FairMQSink.h
-    devices/FairMQSplitter.h
-    options/FairMQParser.h
-    options/FairMQSuboptParser.h
-    options/FairProgOptionsHelper.h
-    plugins/Builtin.h
-    plugins/Control.h
-    StateMachine.h
-    shmem/FairMQMessageSHM.h
-    shmem/FairMQPollerSHM.h
-    shmem/FairMQUnmanagedRegionSHM.h
-    shmem/FairMQSocketSHM.h
-    shmem/FairMQTransportFactorySHM.h
-    shmem/Common.h
-    shmem/Manager.h
-    shmem/Monitor.h
-    shmem/Region.h
-    zeromq/FairMQMessageZMQ.h
-    zeromq/FairMQPollerZMQ.h
-    zeromq/FairMQUnmanagedRegionZMQ.h
-    zeromq/FairMQSocketZMQ.h
-    zeromq/FairMQTransportFactoryZMQ.h
+  devices/FairMQBenchmarkSampler.h
+  devices/FairMQMerger.h
+  devices/FairMQMultiplier.h
+  devices/FairMQProxy.h
+  devices/FairMQSink.h
+  devices/FairMQSplitter.h
+  options/FairMQParser.h
+  options/FairMQSuboptParser.h
+  options/FairProgOptionsHelper.h
+  plugins/Builtin.h
+  plugins/Control.h
+  StateMachine.h
+  shmem/FairMQMessageSHM.h
+  shmem/FairMQPollerSHM.h
+  shmem/FairMQUnmanagedRegionSHM.h
+  shmem/FairMQSocketSHM.h
+  shmem/FairMQTransportFactorySHM.h
+  shmem/Common.h
+  shmem/Manager.h
+  shmem/Region.h
+  zeromq/FairMQMessageZMQ.h
+  zeromq/FairMQPollerZMQ.h
+  zeromq/FairMQUnmanagedRegionZMQ.h
+  zeromq/FairMQSocketZMQ.h
+  zeromq/FairMQTransportFactoryZMQ.h
 )
 
 if(BUILD_NANOMSG_TRANSPORT)
   set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
-        nanomsg/FairMQMessageNN.h
-        nanomsg/FairMQPollerNN.h
-        nanomsg/FairMQUnmanagedRegionNN.h
-        nanomsg/FairMQSocketNN.h
-        nanomsg/FairMQTransportFactoryNN.h
-    )
+    nanomsg/FairMQMessageNN.h
+    nanomsg/FairMQPollerNN.h
+    nanomsg/FairMQUnmanagedRegionNN.h
+    nanomsg/FairMQSocketNN.h
+    nanomsg/FairMQTransportFactoryNN.h
+  )
 endif()
 
 if(BUILD_OFI_TRANSPORT)
   set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
-        ofi/Context.h
-        ofi/Message.h
-        ofi/Poller.h
-        ofi/Socket.h
-        ofi/TransportFactory.h
-    )
+    ofi/Context.h
+    ofi/Message.h
+    ofi/Poller.h
+    ofi/Socket.h
+    ofi/TransportFactory.h
+  )
 endif()
 
 ##########################
 # libFairMQ source files #
 ##########################
 set(FAIRMQ_SOURCE_FILES
-    DeviceRunner.cxx
-    FairMQChannel.cxx
-    FairMQDevice.cxx
-    FairMQLogger.cxx
-    FairMQMessage.cxx
-    FairMQPoller.cxx
-    FairMQSocket.cxx
-    FairMQStateMachine.cxx
-    FairMQTransportFactory.cxx
-    devices/FairMQBenchmarkSampler.cxx
-    devices/FairMQMerger.cxx
-    devices/FairMQMultiplier.cxx
-    devices/FairMQProxy.cxx
-    devices/FairMQSplitter.cxx
-    options/FairMQParser.cxx
-    options/FairMQProgOptions.cxx
-    options/FairMQSuboptParser.cxx
-    Plugin.cxx
-    PluginManager.cxx
-    PluginServices.cxx
-    plugins/Control.cxx
-    StateMachine.cxx
-    shmem/FairMQMessageSHM.cxx
-    shmem/FairMQPollerSHM.cxx
-    shmem/FairMQUnmanagedRegionSHM.cxx
-    shmem/FairMQSocketSHM.cxx
-    shmem/FairMQTransportFactorySHM.cxx
-    shmem/Manager.cxx
-    shmem/Monitor.cxx
-    shmem/Region.cxx
-    tools/Network.cxx
-    tools/Process.cxx
-    tools/Unique.cxx
-    zeromq/FairMQMessageZMQ.cxx
-    zeromq/FairMQPollerZMQ.cxx
-    zeromq/FairMQUnmanagedRegionZMQ.cxx
-    zeromq/FairMQSocketZMQ.cxx
-    zeromq/FairMQTransportFactoryZMQ.cxx
+  DeviceRunner.cxx
+  FairMQChannel.cxx
+  FairMQDevice.cxx
+  FairMQLogger.cxx
+  FairMQMessage.cxx
+  FairMQPoller.cxx
+  FairMQSocket.cxx
+  FairMQStateMachine.cxx
+  FairMQTransportFactory.cxx
+  devices/FairMQBenchmarkSampler.cxx
+  devices/FairMQMerger.cxx
+  devices/FairMQMultiplier.cxx
+  devices/FairMQProxy.cxx
+  devices/FairMQSplitter.cxx
+  options/FairMQParser.cxx
+  options/FairMQProgOptions.cxx
+  options/FairMQSuboptParser.cxx
+  Plugin.cxx
+  PluginManager.cxx
+  PluginServices.cxx
+  plugins/Control.cxx
+  StateMachine.cxx
+  shmem/FairMQMessageSHM.cxx
+  shmem/FairMQPollerSHM.cxx
+  shmem/FairMQUnmanagedRegionSHM.cxx
+  shmem/FairMQSocketSHM.cxx
+  shmem/FairMQTransportFactorySHM.cxx
+  shmem/Manager.cxx
+  shmem/Region.cxx
+  tools/Network.cxx
+  tools/Process.cxx
+  tools/Unique.cxx
+  zeromq/FairMQMessageZMQ.cxx
+  zeromq/FairMQPollerZMQ.cxx
+  zeromq/FairMQUnmanagedRegionZMQ.cxx
+  zeromq/FairMQSocketZMQ.cxx
+  zeromq/FairMQTransportFactoryZMQ.cxx
+  MemoryResources.cxx
 )
 
 if(BUILD_NANOMSG_TRANSPORT)
-    set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
-        nanomsg/FairMQMessageNN.cxx
-        nanomsg/FairMQPollerNN.cxx
-        nanomsg/FairMQUnmanagedRegionNN.cxx
-        nanomsg/FairMQSocketNN.cxx
-        nanomsg/FairMQTransportFactoryNN.cxx
-    )
+  set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
+    nanomsg/FairMQMessageNN.cxx
+    nanomsg/FairMQPollerNN.cxx
+    nanomsg/FairMQUnmanagedRegionNN.cxx
+    nanomsg/FairMQSocketNN.cxx
+    nanomsg/FairMQTransportFactoryNN.cxx
+  )
 endif()
 
 if(BUILD_OFI_TRANSPORT)
-    set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
-        ofi/Context.cxx
-        ofi/Message.cxx
-        ofi/Poller.cxx
-        ofi/Socket.cxx
-        ofi/TransportFactory.cxx
-    )
+  set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
+    ofi/Context.cxx
+    ofi/Message.cxx
+    ofi/Poller.cxx
+    ofi/Socket.cxx
+    ofi/TransportFactory.cxx
+  )
 endif()
 
 
@@ -197,7 +197,7 @@ if(FAST_BUILD)
 else()
   set(_target FairMQ)
 endif()
-add_library(${_target} SHARED
+add_library(${_target}
   ${FAIRMQ_SOURCE_FILES}
   ${FAIRMQ_PUBLIC_HEADER_FILES} # for IDE integration
   ${FAIRMQ_PRIVATE_HEADER_FILES} # for IDE integration
@@ -206,17 +206,20 @@ set_target_properties(${_target} PROPERTIES LABELS coverage)
 if(FAST_BUILD)
   set_target_properties(${_target} PROPERTIES OUTPUT_NAME FairMQ)
 endif()
+if(Boost_VERSION VERSION_LESS 1.66)
+  target_compile_definitions(${_target} PUBLIC FAIR_MQ_HAS_NO_ASIO_IO_CONTEXT)
+endif()
 
 #######################
 # include directories #
 #######################
 target_include_directories(${_target}
-    PUBLIC # consumers inherit public include directories
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
-    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>
-    $<INSTALL_INTERFACE:include/fairmq>
-    $<INSTALL_INTERFACE:include>
+  PUBLIC # consumers inherit public include directories
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+  $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+  $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>
+  $<INSTALL_INTERFACE:include/fairmq>
+  $<INSTALL_INTERFACE:include>
 )
 
 ##################
@@ -234,25 +237,26 @@ if(optional_deps)
 endif()
 
 target_link_libraries(${_target}
-    INTERFACE # only consumers link against interface dependencies
+  INTERFACE # only consumers link against interface dependencies
+  Boost::container
 
-    PUBLIC # libFairMQ AND consumers of libFairMQ link aginst public dependencies
-    Threads::Threads
-    dl
-    Boost::boost
-    Boost::program_options
-    Boost::thread
-    Boost::system
-    Boost::filesystem
-    Boost::regex
-    Boost::date_time
-    Boost::signals
-    FairLogger::FairLogger
+  PUBLIC # libFairMQ AND consumers of libFairMQ link aginst public dependencies
+  Threads::Threads
+  dl
+  $<$<PLATFORM_ID:Linux>:rt>
+  Boost::boost
+  Boost::program_options
+  Boost::thread
+  Boost::system
+  Boost::filesystem
+  Boost::regex
+  Boost::date_time
+  FairLogger::FairLogger
 
-    PRIVATE # only libFairMQ links against private dependencies
-    libzmq
-    ${NANOMSG_DEPS}
-    ${OFI_DEPS}
+  PRIVATE # only libFairMQ links against private dependencies
+  libzmq
+  ${NANOMSG_DEPS}
+  ${OFI_DEPS}
 )
 set_target_properties(${_target} PROPERTIES
   VERSION ${PROJECT_GIT_VERSION}
@@ -299,8 +303,17 @@ target_link_libraries(fairmq-splitter FairMQ)
 add_executable(runConfigExample options/runConfigEx.cxx)
 target_link_libraries(runConfigExample FairMQ)
 
-add_executable(fairmq-shmmonitor shmem/runMonitor.cxx)
-target_link_libraries(fairmq-shmmonitor FairMQ)
+add_executable(fairmq-shmmonitor shmem/Monitor.cxx shmem/Monitor.h shmem/runMonitor.cxx)
+target_link_libraries(fairmq-shmmonitor PUBLIC
+  Threads::Threads
+  $<$<PLATFORM_ID:Linux>:rt>
+  Boost::boost
+  Boost::date_time
+  Boost::program_options
+)
+target_include_directories(fairmq-shmmonitor PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+)
 
 add_executable(fairmq-uuid-gen run/runUuidGenerator.cxx)
 target_link_libraries(fairmq-uuid-gen FairMQ)
@@ -310,27 +323,28 @@ target_link_libraries(fairmq-uuid-gen FairMQ)
 # install #
 ###########
 install(
-    TARGETS
-    FairMQ
-    fairmq-bsampler
-    fairmq-merger
-    fairmq-multiplier
-    fairmq-proxy
-    fairmq-sink
-    fairmq-splitter
-    fairmq-shmmonitor
-    fairmq-uuid-gen
+  TARGETS
+  FairMQ
+  fairmq-bsampler
+  fairmq-merger
+  fairmq-multiplier
+  fairmq-proxy
+  fairmq-sink
+  fairmq-splitter
+  fairmq-shmmonitor
+  fairmq-uuid-gen
 
-    EXPORT ${PROJECT_EXPORT_SET}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  EXPORT ${PROJECT_EXPORT_SET}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${PROJECT_INSTALL_LIBDIR}
 )
 
 # preserve relative path and prepend fairmq
 foreach(HEADER ${FAIRMQ_PUBLIC_HEADER_FILES})
-    get_filename_component(_path ${HEADER} DIRECTORY)
-    file(TO_CMAKE_PATH ${PROJECT_INSTALL_INCDIR}/${_path} _destination)
-    install(FILES ${HEADER}
-        DESTINATION ${_destination}
-    )
+  get_filename_component(_path ${HEADER} DIRECTORY)
+  file(TO_CMAKE_PATH ${PROJECT_INSTALL_INCDIR}/${_path} _destination)
+  install(FILES ${HEADER}
+    DESTINATION ${_destination}
+  )
 endforeach()

fairmq/DeviceRunner.cxx

@@ -1,5 +1,5 @@
 /********************************************************************************
- *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2017-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -7,16 +7,19 @@
  ********************************************************************************/
 
 #include "DeviceRunner.h"
-#include <fairmq/Tools.h>
+
 #include <exception>
+#include <fairmq/Tools.h>
+#include <fairmq/Version.h>
 
 using namespace fair::mq;
 
-DeviceRunner::DeviceRunner(int argc, char* const argv[])
+DeviceRunner::DeviceRunner(int argc, char* const argv[], bool printLogo)
     : fRawCmdLineArgs(tools::ToStrVector(argc, argv, false))
     , fConfig()
     , fDevice(nullptr)
     , fPluginManager(fRawCmdLineArgs)
+    , fPrintLogo(printLogo)
     , fEvents()
 {}
 
@@ -33,26 +36,34 @@ auto DeviceRunner::Run() -> int
     fEvents.Emit<hooks::SetCustomCmdLineOptions>(*this);
     ////////////////////////
 
-    fPluginManager.ForEachPluginProgOptions([&](boost::program_options::options_description options){
-        fConfig.AddToCmdLineOptions(options);
-    });
+    fPluginManager.ForEachPluginProgOptions(
+        [&](boost::program_options::options_description options) {
+            fConfig.AddToCmdLineOptions(options);
+        });
     fConfig.AddToCmdLineOptions(fPluginManager.ProgramOptions());
 
     ////// CALL HOOK ///////
     fEvents.Emit<hooks::ModifyRawCmdLineArgs>(*this);
     ////////////////////////
 
-    if (fConfig.ParseAll(fRawCmdLineArgs, true))
-    {
+    if (fConfig.ParseAll(fRawCmdLineArgs, true)) {
         return 0;
     }
 
+    if (fPrintLogo) {
+        LOG(info) << std::endl
+                  << "      ______      _    _______  _________ " << std::endl
+                  << "     / ____/___ _(_)_______   |/  /_  __ \\    version " << FAIRMQ_GIT_VERSION << std::endl
+                  << "    / /_  / __ `/ / ___/__  /|_/ /_  / / /    build " << FAIRMQ_BUILD_TYPE << std::endl
+                  << "   / __/ / /_/ / / /    _  /  / / / /_/ /     " << FAIRMQ_REPO_URL << std::endl
+                  << "  /_/    \\__,_/_/_/     /_/  /_/  \\___\\_\\     " << FAIRMQ_LICENSE << "  © " << FAIRMQ_COPYRIGHT << std::endl;
+    }
+
     ////// CALL HOOK ///////
     fEvents.Emit<hooks::InstantiateDevice>(*this);
     ////////////////////////
 
-    if (!fDevice)
-    {
+    if (!fDevice) {
         LOG(error) << "getDevice(): no valid device provided. Exiting.";
         return 1;
     }
@@ -61,16 +72,14 @@ auto DeviceRunner::Run() -> int
 
     // Handle --print-channels
     fDevice->RegisterChannelEndpoints();
-    if (fConfig.Count("print-channels"))
-    {
+    if (fConfig.Count("print-channels")) {
         fDevice->PrintRegisteredChannels();
         fDevice->ChangeState(FairMQDevice::END);
         return 0;
     }
 
     // Handle --version
-    if (fConfig.Count("version"))
-    {
+    if (fConfig.Count("version")) {
         std::cout << "User device version: " << fDevice->GetVersion() << std::endl;
         std::cout << "FAIRMQ_INTERFACE_VERSION: " << FAIRMQ_INTERFACE_VERSION << std::endl;
         fDevice->ChangeState(FairMQDevice::END);
@@ -99,18 +108,13 @@ auto DeviceRunner::Run() -> int
 
 auto DeviceRunner::RunWithExceptionHandlers() -> int
 {
-    try
-    {
+    try {
         return Run();
-    }
-    catch (std::exception& e)
-    {
-        LOG(error) << "Unhandled exception reached the top of main: " << e.what() << ", application will now exit";
+    } catch (std::exception& e) {
+        LOG(error) << "Uncaught exception reached the top of DeviceRunner: " << e.what();
         return 1;
-    }
-    catch (...)
-    {
-        LOG(error) << "Non-exception instance being thrown. Please make sure you use std::runtime_exception() instead. Application will now exit.";
+    } catch (...) {
+        LOG(error) << "Uncaught exception reached the top of DeviceRunner.";
         return 1;
     }
 }

fairmq/DeviceRunner.h

@@ -1,5 +1,5 @@
 /********************************************************************************
- *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2017-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -20,10 +20,8 @@
 #include <string>
 #include <vector>
 
-namespace fair
-{
-namespace mq
-{
+namespace fair {
+namespace mq {
 
 /**
  * @class DeviceRunner DeviceRunner.h <fairmq/DeviceRunner.h>
@@ -31,7 +29,8 @@ namespace mq
  *
  * Runs a single FairMQ device with config and plugin support.
  *
- * For customization user hooks are executed at various steps during device launch/shutdown in the following sequence:
+ * For customization user hooks are executed at various steps during device launch/shutdown in the
+ * following sequence:
  *
  *         LoadPlugins
  *              |
@@ -44,34 +43,41 @@ namespace mq
  *              v
  *      InstatiateDevice
  *
- * Each hook has access to all members of the DeviceRunner and really only differs by the point in time it is called.
+ * Each hook has access to all members of the DeviceRunner and really only differs by the point in
+ * time it is called.
  *
  * For an example usage of this class see the fairmq/runFairMQDevice.h header.
  */
 class DeviceRunner
 {
   public:
-    DeviceRunner(int argc, char* const argv[]);
+    DeviceRunner(int argc, char* const argv[], bool printLogo = true);
 
     auto Run() -> int;
     auto RunWithExceptionHandlers() -> int;
 
     template<typename H>
-    auto AddHook(std::function<void(DeviceRunner&)> hook) -> void { fEvents.Subscribe<H>("runner", hook); }
+    auto AddHook(std::function<void(DeviceRunner&)> hook) -> void
+    {
+        fEvents.Subscribe<H>("runner", hook);
+    }
     template<typename H>
-    auto RemoveHook() -> void { fEvents.Unsubscribe<H>("runner"); }
+    auto RemoveHook() -> void
+    {
+        fEvents.Unsubscribe<H>("runner");
+    }
 
     std::vector<std::string> fRawCmdLineArgs;
     FairMQProgOptions fConfig;
     std::unique_ptr<FairMQDevice> fDevice;
     PluginManager fPluginManager;
+    const bool fPrintLogo;
 
   private:
     EventManager fEvents;
 };
 
-namespace hooks
-{
+namespace hooks {
 struct LoadPlugins : Event<DeviceRunner&> {};
 struct SetCustomCmdLineOptions : Event<DeviceRunner&> {};
 struct ModifyRawCmdLineArgs : Event<DeviceRunner&> {};

fairmq/FairMQChannel.h

@@ -10,10 +10,12 @@
 #define FAIRMQCHANNEL_H_
 
 #include <string>
-#include <memory> // unique_ptr
+#include <memory> // unique_ptr, shared_ptr
 #include <vector>
 #include <atomic>
 #include <mutex>
+#include <stdexcept>
+#include <utility> // std::move
 
 #include <FairMQTransportFactory.h>
 #include <FairMQSocket.h>
@@ -42,6 +44,14 @@ class FairMQChannel
     /// @param factory TransportFactory
     FairMQChannel(const std::string& name, const std::string& type, std::shared_ptr<FairMQTransportFactory> factory);
 
+    /// Constructor
+    /// @param name Channel name
+    /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
+    /// @param method Socket method (bind/connect)
+    /// @param address Network address to bind/connect to (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
+    /// @param factory TransportFactory
+    FairMQChannel(const std::string& name, const std::string& type, const std::string& method, const std::string& address, std::shared_ptr<FairMQTransportFactory> factory);
+
     /// Copy Constructor
     FairMQChannel(const FairMQChannel&);
 
@@ -49,18 +59,20 @@ class FairMQChannel
     FairMQChannel& operator=(const FairMQChannel&);
 
     /// Default destructor
-    virtual ~FairMQChannel();
+    virtual ~FairMQChannel() {}
 
-    FairMQSocket const & GetSocket() const;
+    struct ChannelConfigurationError : std::runtime_error { using std::runtime_error::runtime_error; };
 
-    auto Bind(const std::string& address) -> bool
+    FairMQSocket& GetSocket() const;
+
+    bool Bind(const std::string& address)
     {
         fMethod = "bind";
         fAddress = address;
         return fSocket->Bind(address);
     }
 
-    auto Connect(const std::string& address) -> void
+    bool Connect(const std::string& address)
     {
         fMethod = "connect";
         fAddress = address;
@@ -69,15 +81,18 @@ class FairMQChannel
 
     /// Get channel name
     /// @return Returns full channel name (e.g. "data[0]")
-    std::string GetChannelName() const;
+    std::string GetChannelName() const { return GetName(); } // TODO: deprecate this in favor of following
+    std::string GetName() const;
 
     /// Get channel prefix
     /// @return Returns channel prefix (e.g. "data" in "data[0]")
-    std::string GetChannelPrefix() const;
+    std::string GetChannelPrefix() const { return GetPrefix(); } // TODO: deprecate this in favor of following
+    std::string GetPrefix() const;
 
     /// Get channel index
     /// @return Returns channel index (e.g. 0 in "data[0]")
-    std::string GetChannelIndex() const;
+    std::string GetChannelIndex() const { return GetIndex(); } // TODO: deprecate this in favor of following
+    std::string GetIndex() const;
 
     /// Get socket type
     /// @return Returns socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
@@ -111,10 +126,26 @@ 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;
 
+    /// Get start of the port range for automatic binding
+    /// @return start of the port range
+    int GetPortRangeMin() const;
+
+    /// Get end of the port range for automatic binding
+    /// @return end of the port range
+    int GetPortRangeMax() const;
+
+    /// Set automatic binding (pick random port if bind fails)
+    /// @return true/false, true if automatic binding is enabled
+    bool GetAutoBind() const;
+
     /// Set socket type
     /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
     void UpdateType(const std::string& type);
@@ -147,13 +178,30 @@ 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);
 
+    /// Set start of the port range for automatic binding
+    /// @param minPort start of the port range
+    void UpdatePortRangeMin(const int minPort);
+
+    /// Set end of the port range for automatic binding
+    /// @param maxPort end of the port range
+    void UpdatePortRangeMax(const int maxPort);
+
+    /// Set automatic binding (pick random port if bind fails)
+    /// @param autobind true/false, true to enable automatic binding
+    void UpdateAutoBind(const bool autobind);
+
     /// Set channel name
     /// @param name Arbitrary channel name
-    void UpdateChannelName(const std::string& name);
+    void UpdateChannelName(const std::string& name) { UpdateName(name); } // TODO: deprecate this in favor of following
+    void UpdateName(const std::string& name);
 
     /// Checks if the configured channel settings are valid (checks the validity parameter, without running full validation (as oposed to ValidateChannel()))
     /// @return true if channel settings are valid, false otherwise.
@@ -161,166 +209,163 @@ class FairMQChannel
 
     /// Validates channel configuration
     /// @return true if channel settings are valid, false otherwise.
-    bool ValidateChannel();
+    bool ValidateChannel() // TODO: deprecate this
+    {
+        return Validate();
+    }
+
+    /// Validates channel configuration
+    /// @return true if channel settings are valid, false otherwise.
+    bool Validate();
+
+    void Init();
+
+    bool ConnectEndpoint(const std::string& endpoint);
+
+    bool BindEndpoint(std::string& endpoint);
 
     /// 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)
+    {
+        CheckSendCompatibility(msg);
+        return fSocket->Send(msg, sndTimeoutInMs);
+    }
 
     /// 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)
+    {
+        CheckReceiveCompatibility(msg);
+        return fSocket->Receive(msg, rcvTimeoutInMs);
+    }
 
-    /// 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);")))
+    {
+        CheckSendCompatibility(msg);
+        return fSocket->Send(msg, 0);
+    }
+    int ReceiveAsync(FairMQMessagePtr& msg) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msg, timeout);")))
+    {
+        CheckReceiveCompatibility(msg);
+        return fSocket->Receive(msg, 0);
+    }
 
     /// 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)
+    {
+        CheckSendCompatibility(msgVec);
+        return fSocket->Send(msgVec, sndTimeoutInMs);
+    }
 
     /// 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;
-
-    /// 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;
-
-    /// 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
+    /// @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)
     {
-        return Send(parts.fParts);
+        CheckReceiveCompatibility(msgVec);
+        return fSocket->Receive(msgVec, rcvTimeoutInMs);
     }
 
-    int64_t Receive(FairMQParts& parts) const
+    int64_t SendAsync(std::vector<FairMQMessagePtr>& msgVec) __attribute__((deprecated("For non-blocking Send, use timeout version with timeout of 0: Send(msgVec, timeout);")))
     {
-        return Receive(parts.fParts);
+        CheckSendCompatibility(msgVec);
+        return fSocket->Send(msgVec, 0);
+    }
+    int64_t ReceiveAsync(std::vector<FairMQMessagePtr>& msgVec) __attribute__((deprecated("For non-blocking Receive, use timeout version with timeout of 0: Receive(msgVec, timeout);")))
+    {
+        CheckReceiveCompatibility(msgVec);
+        return fSocket->Receive(msgVec, 0);
     }
 
-    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;
-    unsigned long GetBytesRx() const;
-    unsigned long GetMessagesTx() const;
-    unsigned long GetMessagesRx() const;
+    unsigned long GetBytesTx() const { return fSocket->GetBytesTx(); }
+    unsigned long GetBytesRx() const { return fSocket->GetBytesRx(); }
+    unsigned long GetMessagesTx() const { return fSocket->GetMessagesTx(); }
+    unsigned long GetMessagesRx() const { return fSocket->GetMessagesRx(); }
 
-    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);
     }
 
   private:
+    std::shared_ptr<FairMQTransportFactory> fTransportFactory;
+    fair::mq::Transport fTransportType;
     std::unique_ptr<FairMQSocket> fSocket;
 
     std::string fType;
     std::string fMethod;
     std::string fAddress;
-    fair::mq::Transport fTransportType;
     int fSndBufSize;
     int fRcvBufSize;
     int fSndKernelSize;
     int fRcvKernelSize;
+    int fLinger;
     int fRateLogging;
+    int fPortRangeMin;
+    int fPortRangeMax;
+    bool fAutoBind;
 
     std::string fName;
     std::atomic<bool> fIsValid;
 
-    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 InitTransport(std::shared_ptr<FairMQTransportFactory> factory);
-
     // use static mutex to make the class easily copyable
     // implication: same mutex is used for all instances of the class
     // this does not hurt much, because mutex is used only during initialization with very low contention
@@ -329,8 +374,66 @@ class FairMQChannel
 
     bool fMultipart;
     bool fModified;
-    auto SetModified(const bool modified) -> void;
     bool fReset;
+
+    void CheckSendCompatibility(FairMQMessagePtr& msg)
+    {
+        if (fTransportType != msg->GetType()) {
+            // LOG(debug) << "Channel type does not match message type. Creating wrapper";
+            FairMQMessagePtr msgWrapper(NewMessage(
+                msg->GetData(),
+                msg->GetSize(),
+                [](void* /*data*/, void* _msg) { delete static_cast<FairMQMessage*>(_msg); },
+                msg.get()
+            ));
+            msg.release();
+            msg = move(msgWrapper);
+        }
+    }
+
+    void CheckSendCompatibility(std::vector<FairMQMessagePtr>& msgVec)
+    {
+        for (auto& msg : msgVec) {
+            if (fTransportType != msg->GetType()) {
+                // LOG(debug) << "Channel type does not match message type. Creating wrapper";
+                FairMQMessagePtr msgWrapper(NewMessage(
+                    msg->GetData(),
+                    msg->GetSize(),
+                    [](void* /*data*/, void* _msg) { delete static_cast<FairMQMessage*>(_msg); },
+                    msg.get()
+                ));
+                msg.release();
+                msg = move(msgWrapper);
+            }
+        }
+    }
+
+    void CheckReceiveCompatibility(FairMQMessagePtr& msg)
+    {
+        if (fTransportType != msg->GetType()) {
+            // LOG(debug) << "Channel type does not match message type. Creating wrapper";
+            FairMQMessagePtr newMsg(NewMessage());
+            msg = move(newMsg);
+        }
+    }
+
+    void CheckReceiveCompatibility(std::vector<FairMQMessagePtr>& msgVec)
+    {
+        for (auto& msg : msgVec) {
+            if (fTransportType != msg->GetType()) {
+                // LOG(debug) << "Channel type does not match message type. Creating wrapper";
+                FairMQMessagePtr newMsg(NewMessage());
+                msg = move(newMsg);
+            }
+        }
+    }
+
+    void InitTransport(std::shared_ptr<FairMQTransportFactory> factory)
+    {
+        fTransportFactory = factory;
+        fTransportType = factory->GetType();
+    }
+    auto SetModified(const bool modified) -> void;
 };
 
 #endif /* FAIRMQCHANNEL_H_ */

fairmq/FairMQDevice.cxx

@@ -16,14 +16,13 @@
 
 #include <list>
 #include <cstdlib>
-#include <stdexcept>
-#include <random>
 #include <chrono>
 #include <mutex>
 #include <thread>
 #include <functional>
 #include <sstream>
 #include <iomanip>
+#include <future>
 #include <algorithm> // std::max
 
 using namespace std;
@@ -55,11 +54,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)
     , fDataCallbacks(false)
     , fMsgInputs()
@@ -72,6 +66,10 @@ FairMQDevice::FairMQDevice(FairMQProgOptions* config, const fair::mq::tools::Ver
     , fVersion(version)
     , fRate(0.)
     , fRawCmdLineArgs()
+    , fInterrupted(false)
+    , fInterruptedCV()
+    , fInterruptedMtx()
+    , fRateLogging(true)
 {
 }
 
@@ -79,27 +77,20 @@ void FairMQDevice::InitWrapper()
 {
     fId = fConfig->GetValue<string>("id");
     fRate = fConfig->GetValue<float>("rate");
-    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())
-    {
-        if (fChannels.find(c.first) == fChannels.end())
-        {
+    for (auto& c : fConfig->GetFairMQMap()) {
+        if (fChannels.find(c.first) == fChannels.end()) {
             LOG(debug) << "Inserting new device channel from config: " << c.first;
             fChannels.insert(c);
-        }
-        else
-        {
+        } else {
             LOG(debug) << "Updating existing device channel from config: " << c.first;
             fChannels[c.first] = c.second;
         }
@@ -115,51 +106,44 @@ void FairMQDevice::InitWrapper()
     string networkInterface = fConfig->GetValue<string>("network-interface");
 
     // Fill the uninitialized channel containers
-    for (auto& mi : fChannels)
-    {
-        for (auto vi = mi.second.begin(); vi != mi.second.end(); ++vi)
-        {
-            // if (vi->fModified)
-            // {
-                // if (vi->fReset)
-                // {
-                //     vi->fSocket.reset();
-                // }
-                // set channel name: name + vector index
-                vi->fName = fair::mq::tools::ToString(mi.first, "[", vi - (mi.second).begin(), "]");
+    for (auto& mi : fChannels) {
+        int subChannelIndex = 0;
+        for (auto& vi : mi.second) {
+            // set channel name: name + vector index
+            vi.fName = fair::mq::tools::ToString(mi.first, "[", subChannelIndex, "]");
 
-                if (vi->fMethod == "bind")
-                {
-                    // if binding address is not specified, try getting it from the configured network interface
-                    if (vi->fAddress == "unspecified" || vi->fAddress == "")
-                    {
-                        // if the configured network interface is default, get its name from the default route
-                        if (networkInterface == "default")
-                        {
-                            networkInterface = fair::mq::tools::getDefaultRouteNetworkInterface();
-                        }
-                        vi->fAddress = "tcp://" + fair::mq::tools::getInterfaceIP(networkInterface) + ":1";
+            // set channel transport
+            if (vi.fTransportType == fair::mq::Transport::DEFAULT || vi.fTransportType == fTransportFactory->GetType()) {
+                LOG(debug) << vi.fName << ": using default transport";
+                vi.InitTransport(fTransportFactory);
+            } else {
+                LOG(debug) << vi.fName << ": channel transport (" << fair::mq::TransportNames.at(fDefaultTransportType) << ") overriden to " << fair::mq::TransportNames.at(vi.fTransportType);
+                vi.InitTransport(AddTransport(vi.fTransportType));
+            }
+
+            if (vi.fMethod == "bind") {
+                // if binding address is not specified, try getting it from the configured network interface
+                if (vi.fAddress == "unspecified" || vi.fAddress == "") {
+                    // if the configured network interface is default, get its name from the default route
+                    if (networkInterface == "default") {
+                        networkInterface = fair::mq::tools::getDefaultRouteNetworkInterface();
                     }
-                    // fill the uninitialized list
-                    uninitializedBindingChannels.push_back(&(*vi));
+                    vi.fAddress = "tcp://" + fair::mq::tools::getInterfaceIP(networkInterface) + ":1";
                 }
-                else if (vi->fMethod == "connect")
-                {
-                    // fill the uninitialized list
-                    uninitializedConnectingChannels.push_back(&(*vi));
-                }
-                else if (vi->fAddress.find_first_of("@+>") != string::npos)
-                {
-                    // fill the uninitialized list
-                    uninitializedConnectingChannels.push_back(&(*vi));
-                }
-                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.");
-                }
-            // }
+                // fill the uninitialized list
+                uninitializedBindingChannels.push_back(&vi);
+            } else if (vi.fMethod == "connect") {
+                // fill the uninitialized list
+                uninitializedConnectingChannels.push_back(&vi);
+            } else if (vi.fAddress.find_first_of("@+>") != string::npos) {
+                // fill the uninitialized list
+                uninitializedConnectingChannels.push_back(&vi);
+            } else {
+                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."));
+            }
+
+            subChannelIndex++;
         }
     }
 
@@ -167,22 +151,13 @@ 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)
@@ -192,28 +167,20 @@ void FairMQDevice::InitWrapper()
     // first attempt
     AttachChannels(uninitializedConnectingChannels);
     // if not all channels could be connected, update their address values from config and retry
-    while (!uninitializedConnectingChannels.empty())
-    {
+    while (!uninitializedConnectingChannels.empty()) {
         this_thread::sleep_for(chrono::milliseconds(sleepTimeInMS));
 
-        if (fConfig)
-        {
-            for (auto& chan : uninitializedConnectingChannels)
-            {
-                string key{"chans." + chan->GetChannelPrefix() + "." + chan->GetChannelIndex() + ".address"};
-                string newAddress = fConfig->GetValue<string>(key);
-                if (newAddress != chan->GetAddress())
-                {
-                    chan->UpdateAddress(newAddress);
-                }
+        for (auto& chan : uninitializedConnectingChannels) {
+            string key{"chans." + chan->GetChannelPrefix() + "." + chan->GetChannelIndex() + ".address"};
+            string newAddress = fConfig->GetValue<string>(key);
+            if (newAddress != chan->GetAddress()) {
+                chan->UpdateAddress(newAddress);
             }
         }
 
-        if (numAttempts++ > maxAttempts)
-        {
+        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);
@@ -221,13 +188,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()
@@ -238,103 +203,54 @@ void FairMQDevice::AttachChannels(vector<FairMQChannel*>& chans)
 {
     auto itr = chans.begin();
 
-    while (itr != chans.end())
-    {
-        if ((*itr)->ValidateChannel())
-        {
-            if (AttachChannel(**itr))
-            {
+    while (itr != chans.end()) {
+        if ((*itr)->ValidateChannel()) {
+            (*itr)->Init();
+            if (AttachChannel(**itr)) {
                 (*itr)->SetModified(false);
+                // remove the channel from the uninitialized container
                 itr = chans.erase(itr);
-            }
-            else
-            {
+            } else {
                 LOG(error) << "failed to attach channel " << (*itr)->fName << " (" << (*itr)->fMethod << ")";
                 ++itr;
             }
-        }
-        else
-        {
+        } else {
             ++itr;
         }
     }
 }
 
-bool FairMQDevice::AttachChannel(FairMQChannel& ch)
+bool FairMQDevice::AttachChannel(FairMQChannel& chan)
 {
-    if (ch.fTransportType == fair::mq::Transport::DEFAULT || ch.fTransportType == fTransportFactory->GetType())
-    {
-        LOG(debug) << ch.fName << ": using default transport";
-        ch.InitTransport(fTransportFactory);
-    }
-    else
-    {
-        LOG(debug) << ch.fName << ": channel transport (" << fair::mq::TransportNames.at(fDefaultTransportType) << ") overriden to " << fair::mq::TransportNames.at(ch.fTransportType);
-        ch.InitTransport(AddTransport(ch.fTransportType));
-    }
-
     vector<string> endpoints;
-    boost::algorithm::split(endpoints, ch.fAddress, boost::algorithm::is_any_of(","));
-    for (auto& endpoint : endpoints)
-    {
-        //(re-)init socket
-        if (!ch.fSocket)
-        {
-            try
-            {
-                ch.fSocket = ch.fTransportFactory->CreateSocket(ch.fType, ch.fName);
-            }
-            catch (fair::mq::SocketError& se)
-            {
-                LOG(error) << se.what();
-                return false;
-            }
-        }
-
-        // 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 kernel transmit size
-        if (ch.fSndKernelSize != 0)
-        {
-            ch.fSocket->SetOption("snd-size", &(ch.fSndKernelSize), sizeof(ch.fSndKernelSize));
-        }
-        if (ch.fRcvKernelSize != 0)
-        {
-            ch.fSocket->SetOption("rcv-size", &(ch.fRcvKernelSize), sizeof(ch.fRcvKernelSize));
-        }
+    string chanAddress = chan.GetAddress();
+    boost::algorithm::split(endpoints, chanAddress, boost::algorithm::is_any_of(","));
 
+    for (auto& endpoint : endpoints) {
         // attach
-        bool bind = (ch.fMethod == "bind");
+        bool bind = (chan.GetMethod() == "bind");
         bool connectionModifier = false;
         string address = endpoint;
 
         // check if the default fMethod is overridden by a modifier
-        if (endpoint[0] == '+' || endpoint[0] == '>')
-        {
+        if (endpoint[0] == '+' || endpoint[0] == '>') {
             connectionModifier = true;
             bind = false;
             address = endpoint.substr(1);
-        }
-        else if (endpoint[0] == '@')
-        {
+        } else if (endpoint[0] == '@') {
             connectionModifier = true;
             bind = true;
             address = endpoint.substr(1);
         }
 
-        if (address.compare(0, 6, "tcp://") == 0)
-        {
+        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 == "*"))
-            {
+            if (!(bind && hostPart == "*")) {
                 string portPart = addressString.substr(pos + 1);
                 string resolvedHost = fair::mq::tools::getIpFromHostname(hostPart);
-                if (resolvedHost == "")
-                {
+                if (resolvedHost == "") {
                     return false;
                 }
                 address.assign("tcp://" + resolvedHost + ":" + portPart);
@@ -343,79 +259,35 @@ bool FairMQDevice::AttachChannel(FairMQChannel& ch)
 
         bool success = true;
         // make the connection
-        if (bind)
-        {
-            success = BindEndpoint(*ch.fSocket, address);
-        }
-        else
-        {
-            success = ConnectEndpoint(*ch.fSocket, address);
+        if (bind) {
+            success = chan.BindEndpoint(address);
+        } else {
+            success = chan.ConnectEndpoint(address);
         }
 
         // bind might bind to an address different than requested,
         // put the actual address back in the config
         endpoint.clear();
-        if (connectionModifier)
-        {
+        if (connectionModifier) {
             endpoint.push_back(bind?'@':'+');
         }
         endpoint += address;
 
-        LOG(debug) << "Attached channel " << ch.fName << " to " << endpoint << (bind ? " (bind) " : " (connect) ");
-
         // after the book keeping is done, exit in case of errors
-        if (!success)
-        {
+        if (!success) {
             return success;
+        } else {
+            LOG(debug) << "Attached channel " << chan.GetName() << " to " << endpoint << (bind ? " (bind) " : " (connect) ") << "(" << chan.GetType() << ")";
         }
     }
 
     // put the (possibly) modified address back in the channel object and config
-    string newAddress{boost::algorithm::join(endpoints, ",")};
-    if (newAddress != ch.fAddress)
-    {
-        ch.UpdateAddress(newAddress);
-        if (fConfig)
-        {
-            string key{"chans." + ch.GetChannelPrefix() + "." + ch.GetChannelIndex() + ".address"};
-            fConfig->SetValue(key, newAddress);
-        }
-    }
+    string newAddress(boost::algorithm::join(endpoints, ","));
+    if (newAddress != chanAddress) {
+        chan.UpdateAddress(newAddress);
 
-    return true;
-}
-
-bool FairMQDevice::ConnectEndpoint(FairMQSocket& socket, string& endpoint)
-{
-    socket.Connect(endpoint);
-
-    return true;
-}
-
-bool FairMQDevice::BindEndpoint(FairMQSocket& socket, string& endpoint)
-{
-    // number of attempts when choosing a random port
-    int maxAttempts = 1000;
-    int numAttempts = 0;
-
-    // initialize random generator
-    default_random_engine generator(chrono::system_clock::now().time_since_epoch().count());
-    uniform_int_distribution<int> randomPort(fPortRangeMin, fPortRangeMax);
-
-    // try to bind to the saved port. In case of failure, try random one.
-    while (!socket.Bind(endpoint))
-    {
-        LOG(debug) << "Could not bind to configured (TCP) port, trying random port in range " << fPortRangeMin << "-" << fPortRangeMax;
-        ++numAttempts;
-
-        if (numAttempts > maxAttempts)
-        {
-            LOG(error) << "could not bind to any (TCP) port in the given range after " << maxAttempts << " attempts";
-            return false;
-        }
-
-        size_t pos = endpoint.rfind(":");
-        endpoint = endpoint.substr(0, pos + 1) + fair::mq::tools::ToString(static_cast<int>(randomPort(generator)));
+        // update address in the config, it could have been modified during binding
+        fConfig->SetValue({"chans." + chan.GetPrefix() + "." + chan.GetIndex() + ".address"}, newAddress);
     }
 
     return true;
@@ -460,27 +332,6 @@ void FairMQDevice::SortChannel(const string& name, const bool reindex)
     }
 }
 
-void FairMQDevice::PrintChannel(const string& name)
-{
-    if (fChannels.find(name) != fChannels.end())
-    {
-        for (auto vi = fChannels[name].begin(); vi != fChannels[name].end(); ++vi)
-        {
-            LOG(info) << vi->fName << ": "
-                      << vi->fType << " | "
-                      << vi->fMethod << " | "
-                      << vi->fAddress << " | "
-                      << vi->fSndBufSize << " | "
-                      << vi->fRcvBufSize << " | "
-                      << vi->fRateLogging;
-        }
-    }
-    else
-    {
-        LOG(error) << "Printing failed: no channel with the name \"" << name << "\".";
-    }
-}
-
 void FairMQDevice::RunWrapper()
 {
     CallStateChangeCallbacks(RUNNING);
@@ -488,16 +339,20 @@ void FairMQDevice::RunWrapper()
     LOG(info) << "DEVICE: Running...";
 
     // start the rate logger thread
-    thread rateLogger(&FairMQDevice::LogSocketRates, this);
+    fRateLogging = true;
+    future<void> rateLogger = async(launch::async, &FairMQDevice::LogSocketRates, this);
 
     // notify transports to resume transfers
+    {
+        lock_guard<mutex> guard(fInterruptedMtx);
+        fInterrupted = false;
+    }
     for (auto& t : fTransports)
     {
         t.second->Resume();
     }
 
-    try
-    {
+    try {
         PreRun();
 
         // process either data callbacks or ConditionalRun/Run
@@ -527,11 +382,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.
@@ -542,7 +400,7 @@ void FairMQDevice::RunWrapper()
 
     PostRun();
 
-    rateLogger.join();
+    rateLogger.get();
 }
 
 void FairMQDevice::HandleSingleChannelInput()
@@ -585,17 +443,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;
         }
     }
 
@@ -653,7 +511,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)
@@ -710,11 +568,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());
 
@@ -728,7 +586,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;
 
@@ -809,8 +667,6 @@ void FairMQDevice::LogSocketRates()
     chrono::time_point<chrono::high_resolution_clock> t0;
     chrono::time_point<chrono::high_resolution_clock> t1;
 
-    unsigned long long msSinceLastLog;
-
     vector<FairMQSocket*> filteredSockets;
     vector<string> filteredChannelNames;
     vector<int> logIntervals;
@@ -868,11 +724,11 @@ void FairMQDevice::LogSocketRates()
 
         LOG(debug) << "<channel>: in: <#msgs> (<MB>) out: <#msgs> (<MB>)";
 
-        while (CheckCurrentState(RUNNING))
+        while (fRateLogging)
         {
             t1 = chrono::high_resolution_clock::now();
 
-            msSinceLastLog = chrono::duration_cast<chrono::milliseconds>(t1 - t0).count();
+            unsigned long long msSinceLastLog = chrono::duration_cast<chrono::milliseconds>(t1 - t0).count();
 
             i = 0;
 
@@ -908,7 +764,7 @@ void FairMQDevice::LogSocketRates()
             }
 
             t0 = t1;
-            this_thread::sleep_for(chrono::milliseconds(1000));
+            WaitFor(chrono::milliseconds(1000));
         }
     }
 }
@@ -919,6 +775,12 @@ void FairMQDevice::Unblock()
     {
         t.second->Interrupt();
     }
+    {
+        lock_guard<mutex> guard(fInterruptedMtx);
+        fInterrupted = true;
+        fRateLogging = false;
+    }
+    fInterruptedCV.notify_all();
 }
 
 void FairMQDevice::ResetTaskWrapper()
@@ -938,13 +800,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)
     {
@@ -955,11 +815,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

@@ -25,11 +25,13 @@
 #include <memory> // unique_ptr
 #include <algorithm> // std::sort()
 #include <string>
+#include <chrono>
 #include <iostream>
 #include <unordered_map>
 #include <functional>
 #include <assert.h> // static_assert
 #include <type_traits> // is_trivially_copyable
+#include <stdexcept>
 
 #include <mutex>
 #include <condition_variable>
@@ -79,10 +81,6 @@ class FairMQDevice : public FairMQStateMachine
     /// @param reindex Should reindexing be done
     void SortChannel(const std::string& name, const bool reindex = true);
 
-    /// Prints channel configuration
-    /// @param name Name of the channel
-    void PrintChannel(const std::string& name);
-
     template<typename Serializer, typename DataType, typename... Args>
     void Serialize(FairMQMessage& msg, DataType&& data, Args&&... args) const
     {
@@ -95,154 +93,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)
@@ -252,7 +204,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>
@@ -263,22 +215,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)
@@ -290,7 +242,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.");
                 }
             }
         }
@@ -299,7 +251,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")
@@ -318,6 +270,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))
     {
@@ -344,6 +297,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))
     {
@@ -370,7 +324,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() {}
 
@@ -407,12 +369,6 @@ class FairMQDevice : public FairMQStateMachine
     void SetNumIoThreads(int numIoThreads) { fConfig->SetValue<int>("io-threads", numIoThreads);}
     int GetNumIoThreads() const { return fConfig->GetValue<int>("io-threads"); }
 
-    void SetPortRangeMin(int portRangeMin) { fConfig->SetValue<int>("port-range-min", portRangeMin); }
-    int GetPortRangeMin() const { return fConfig->GetValue<int>("port-range-min"); }
-
-    void SetPortRangeMax(int portRangeMax) { fConfig->SetValue<int>("port-range-max", portRangeMax); }
-    int GetPortRangeMax() const { return fConfig->GetValue<int>("port-range-max"); }
-
     void SetNetworkInterface(const std::string& networkInterface) { fConfig->SetValue<std::string>("network-interface", networkInterface); }
     std::string GetNetworkInterface() const { return fConfig->GetValue<std::string>("network-interface"); }
 
@@ -431,7 +387,21 @@ 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.
+    /// @param duration wait duration
+    template<class Rep, class Period>
+    bool WaitFor(std::chrono::duration<Rep, Period> const& duration)
+    {
+        std::unique_lock<std::mutex> lock(fInterruptedMtx);
+        return !fInterruptedCV.wait_for(lock, duration, [&] { return fInterrupted.load(); }); // return true if no interruption happened
+    }
 
   protected:
     std::shared_ptr<FairMQTransportFactory> fTransportFactory; ///< Default transport factory
@@ -451,50 +421,33 @@ class FairMQDevice : public FairMQStateMachine
     std::string fId; ///< Device ID
 
     /// Additional user initialization (can be overloaded in child classes). Prefer to use InitTask().
-    /// Executed in a worker thread
     virtual void Init();
 
     /// Task initialization (can be overloaded in child classes)
-    /// Executed in a worker thread
     virtual void InitTask();
 
     /// Runs the device (to be overloaded in child classes)
-    /// Executed in a worker thread
     virtual void Run();
 
     /// Called in the RUNNING state once before executing the Run()/ConditionalRun() method
-    /// Executed in a worker thread
     virtual void PreRun();
 
     /// Called during RUNNING state repeatedly until it returns false or device state changes
-    /// Executed in a worker thread
     virtual bool ConditionalRun();
 
     /// Called in the RUNNING state once after executing the Run()/ConditionalRun() method
-    /// Executed in a worker thread
     virtual void PostRun();
 
     /// Handles the PAUSE state
-    /// Executed in a worker thread
     virtual void Pause();
 
     /// Resets the user task (to be overloaded in child classes)
-    /// Executed in a worker thread
     virtual void ResetTask();
 
     /// Resets the device (can be overloaded in child classes)
-    /// Executed in a worker thread
     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)
-
     fair::mq::Transport fDefaultTransportType; ///< Default transport for the device
 
     /// Handles the initialization and the Init() method
@@ -518,15 +471,6 @@ class FairMQDevice : public FairMQStateMachine
 
     /// Attach (bind/connect) channels in the list
     void AttachChannels(std::vector<FairMQChannel*>& chans);
-
-    /// Sets up and connects/binds a socket to an endpoint
-    /// return a string with the actual endpoint if it happens
-    /// to stray from default.
-    bool ConnectEndpoint(FairMQSocket& socket, std::string& endpoint);
-    bool BindEndpoint(FairMQSocket& socket, std::string& endpoint);
-    /// Attaches the channel to all listed endpoints
-    /// the list is comma separated; the default method (bind/connect) is used.
-    /// to override default: prepend "@" to bind, "+" or ">" to connect endpoint.
     bool AttachChannel(FairMQChannel& ch);
 
     void HandleSingleChannelInput();
@@ -534,8 +478,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();
 
@@ -551,6 +495,11 @@ class FairMQDevice : public FairMQStateMachine
     const fair::mq::tools::Version fVersion;
     float fRate; ///< Rate limiting for ConditionalRun
     std::vector<std::string> fRawCmdLineArgs;
+
+    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,15 @@ 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/FairMQPoller.h

@@ -18,8 +18,8 @@ class FairMQPoller
     virtual void Poll(const int timeout) = 0;
     virtual bool CheckInput(const int index) = 0;
     virtual bool CheckOutput(const int index) = 0;
-    virtual bool CheckInput(const std::string channelKey, const int index) = 0;
-    virtual bool CheckOutput(const std::string channelKey, const int index) = 0;
+    virtual bool CheckInput(const std::string& channelKey, const int index) = 0;
+    virtual bool CheckOutput(const std::string& channelKey, const int index) = 0;
 
     virtual ~FairMQPoller() {};
 };

fairmq/FairMQSocket.h

@@ -14,46 +14,52 @@
 #include <memory>
 
 #include "FairMQMessage.h"
+class FairMQTransportFactory;
 
 class FairMQSocket
 {
   public:
     FairMQSocket() {}
+    FairMQSocket(FairMQTransportFactory* fac): fTransport(fac) {}
 
     virtual std::string GetId() = 0;
 
     virtual bool Bind(const std::string& address) = 0;
-    virtual void Connect(const std::string& address) = 0;
+    virtual bool 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;
+    FairMQTransportFactory* GetTransport() { return fTransport; }
+    void SetTransport(FairMQTransportFactory* transport) { fTransport=transport; }
 
     virtual ~FairMQSocket() {};
+
+  private:
+    FairMQTransportFactory* fTransport{nullptr};
 };
 
 using FairMQSocketPtr = std::unique_ptr<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>
@@ -644,16 +645,27 @@ bool FairMQStateMachine::CheckCurrentState(int state) const
 {
     return state == static_pointer_cast<FairMQFSM>(fFsm)->fState;
 }
-bool FairMQStateMachine::CheckCurrentState(string state) const
+bool FairMQStateMachine::CheckCurrentState(const string& state) const
 {
     return state == GetCurrentStateName();
 }
 
 void FairMQStateMachine::ProcessWork()
+try
 {
     static_pointer_cast<FairMQFSM>(fFsm)->ProcessWork();
+} catch(...) {
+    {
+        lock_guard<mutex> lock(static_pointer_cast<FairMQFSM>(fFsm)->fWorkMutex);
+        static_pointer_cast<FairMQFSM>(fFsm)->fWorkActive = false;
+        static_pointer_cast<FairMQFSM>(fFsm)->fWorkAvailable = false;
+        static_pointer_cast<FairMQFSM>(fFsm)->fWorkDoneCondition.notify_one();
+    }
+    ChangeState(ERROR_FOUND);
+    throw;
 }
 
+
 int FairMQStateMachine::GetEventNumber(const string& event)
 {
     return eventNumbers.at(event);

fairmq/FairMQStateMachine.h

@@ -82,7 +82,7 @@ class FairMQStateMachine
     static std::string GetStateName(const State);
     int GetCurrentState() const;
     bool CheckCurrentState(int state) const;
-    bool CheckCurrentState(std::string state) const;
+    bool CheckCurrentState(const std::string& state) const;
 
     // actions to be overwritten by derived classes
     virtual void InitWrapper() {}

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,34 +41,36 @@ 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; }
+    operator fair::mq::ChannelResource*() { 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;
+    virtual FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) = 0;
 
     /// 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 +79,7 @@ class FairMQTransportFactory
 
     virtual void Interrupt() = 0;
     virtual void Resume() = 0;
+    virtual void Reset() = 0;
 
     virtual ~FairMQTransportFactory() {};
 
@@ -89,7 +96,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 +105,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 +119,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,66 @@
+/********************************************************************************
+ *    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 {
+          //container is not required to allocate (like in std::string small string optimization)
+          //in case we get no message we fall back to default (copy) behaviour)
+          targetResource = resource;
+        }
+    }
+
+    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

@@ -21,6 +21,7 @@
 #include <unordered_map>
 #include <mutex>
 #include <condition_variable>
+#include <stdexcept>
 
 namespace fair
 {
@@ -185,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/Version.h.in

@@ -9,11 +9,19 @@
 #ifndef FAIR_MQ_VERSION_H
 
 #define FAIRMQ_VERSION "@PROJECT_VERSION@"
-#define FAIRMQ_VERSION_DEC (@PROJECT_VERSION_MAJOR@ * 10000) + (@PROJECT_VERSION_MINOR@ * 100) + @PROJECT_VERSION_PATCH@
+#define FAIRMQ_VERSION_DEC (@PROJECT_VERSION_MAJOR@ * 100000) \
+                           + (@PROJECT_VERSION_MINOR@ * 1000) \
+                           + (@PROJECT_VERSION_PATCH@ * 10) \
+                           + @PROJECT_VERSION_HOTFIX@
 #define FAIRMQ_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
 #define FAIRMQ_VERSION_MINOR @PROJECT_VERSION_MINOR@
 #define FAIRMQ_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define FAIRMQ_VERSION_HOTFIX @PROJECT_VERSION_HOTFIX@
 #define FAIRMQ_GIT_VERSION "@PROJECT_GIT_VERSION@"
 #define FAIRMQ_GIT_DATE "@PROJECT_GIT_DATE@"
+#define FAIRMQ_REPO_URL "https://github.com/FairRootGroup/FairMQ"
+#define FAIRMQ_LICENSE "LGPL-3.0"
+#define FAIRMQ_COPYRIGHT "2012-2018 GSI"
+#define FAIRMQ_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
 
 #endif // FAIR_MQ_VERSION_H

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)
                 {
@@ -88,7 +94,6 @@ void FairMQBenchmarkSampler::Run()
             }
         }
 
-
         if (fMsgRate > 0)
         {
             rateLimiter.maybe_sleep();

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)
@@ -201,30 +205,6 @@ void FairMQMessageNN::Copy(const FairMQMessage& msg)
     }
 }
 
-void FairMQMessageNN::Copy(const FairMQMessagePtr& msg)
-{
-    if (fMessage)
-    {
-        if (nn_freemsg(fMessage) < 0)
-        {
-            LOG(error) << "failed freeing message, reason: " << nn_strerror(errno);
-        }
-    }
-
-    size_t size = msg->GetSize();
-
-    fMessage = nn_allocmsg(size, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-    else
-    {
-        memcpy(fMessage, static_cast<FairMQMessageNN*>(msg.get())->GetMessage(), size);
-        fSize = size;
-    }
-}
-
 void FairMQMessageNN::CloseMessage()
 {
     if (nn_freemsg(fMessage) < 0)

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;
@@ -49,7 +49,6 @@ class FairMQMessageNN : public FairMQMessage
     fair::mq::Transport GetType() const override;
 
     void Copy(const FairMQMessage& msg) override;
-    void Copy(const FairMQMessagePtr& msg) override;
 
     ~FairMQMessageNN() override;
 

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);
     }
@@ -68,10 +69,9 @@ FairMQPollerNN::FairMQPollerNN(const unordered_map<string, vector<FairMQChannel>
     , fNumItems(0)
     , fOffsetMap()
 {
-    int offset = 0;
-
     try
     {
+        int offset = 0;
         // calculate offsets and the total size of the poll item set
         for (string channel : channelList)
         {
@@ -88,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);
             }
@@ -106,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)
@@ -184,7 +163,7 @@ bool FairMQPollerNN::CheckOutput(const int index)
     return false;
 }
 
-bool FairMQPollerNN::CheckInput(const string channelKey, const int index)
+bool FairMQPollerNN::CheckInput(const string& channelKey, const int index)
 {
     try
     {
@@ -203,7 +182,7 @@ bool FairMQPollerNN::CheckInput(const string channelKey, const int index)
     }
 }
 
-bool FairMQPollerNN::CheckOutput(const string channelKey, const int index)
+bool FairMQPollerNN::CheckOutput(const string& channelKey, const int index)
 {
     try
     {

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,11 +28,13 @@
 #include <msgpack.hpp>
 
 using namespace std;
+using namespace fair::mq;
 
 atomic<bool> FairMQSocketNN::fInterrupted(false);
 
-FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const string& id /*= ""*/)
-    : fSocket(-1)
+FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const string& id /*= ""*/, FairMQTransportFactory* fac /*=nullptr*/)
+    : FairMQSocket{fac}
+    , fSocket(-1)
     , fId(id + "." + name + "." + type)
     , fBytesTx(0)
     , fBytesRx(0)
@@ -39,6 +42,7 @@ FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const str
     , fMessagesRx(0)
     , fSndTimeout(100)
     , fRcvTimeout(100)
+    , fLinger(500)
 {
     if (type == "router" || type == "dealer")
     {
@@ -84,7 +88,7 @@ FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const str
     }
 #endif
 
-    // LOG(info) << "created socket " << fId;
+    LOG(debug) << "Created socket " << GetId();
 }
 
 string FairMQSocketNN::GetId()
@@ -96,38 +100,35 @@ bool FairMQSocketNN::Bind(const string& address)
 {
     // LOG(info) << "bind socket " << fId << " on " << address;
 
-    int eid = nn_bind(fSocket, address.c_str());
-    if (eid < 0)
+    if (nn_bind(fSocket, address.c_str()) < 0)
     {
         LOG(error) << "failed binding socket " << fId << ", reason: " << nn_strerror(errno);
         return false;
     }
+
     return true;
 }
 
-void FairMQSocketNN::Connect(const string& address)
+bool FairMQSocketNN::Connect(const string& address)
 {
     // LOG(info) << "connect socket " << fId << " to " << address;
 
-    int eid = nn_connect(fSocket, address.c_str());
-    if (eid < 0)
+    if (nn_connect(fSocket, address.c_str()) < 0)
     {
         LOG(error) << "failed connecting socket " << fId << ", reason: " << nn_strerror(errno);
+        return false;
     }
+
+    return true;
 }
 
-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 +156,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,9 +192,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 nbytes = -1;
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = NN_DONTWAIT;
+    }
     int elapsed = 0;
 
     FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get());
@@ -205,7 +206,7 @@ int FairMQSocketNN::ReceiveImpl(FairMQMessagePtr& msg, const int flags, const in
     while (true)
     {
         void* ptr = nullptr;
-        nbytes = nn_recv(fSocket, &ptr, NN_MSG, flags);
+        int nbytes = nn_recv(fSocket, &ptr, NN_MSG, flags);
         if (nbytes >= 0)
         {
             fBytesRx += nbytes;
@@ -214,15 +215,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)
@@ -254,8 +251,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;
 
@@ -279,26 +281,20 @@ int64_t FairMQSocketNN::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fla
         }
     }
 
-    int64_t nbytes = -1;
-
     while (true)
     {
-        nbytes = nn_send(fSocket, sbuf.data(), sbuf.size(), flags);
+        int64_t nbytes = nn_send(fSocket, sbuf.data(), sbuf.size(), flags);
         if (nbytes >= 0)
         {
             fBytesTx += nbytes;
             ++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)
@@ -330,8 +326,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)
     // {
@@ -368,7 +369,7 @@ int64_t FairMQSocketNN::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int
                 object.convert(buf);
                 // get the single message size
                 size_t size = buf.size() * sizeof(char);
-                FairMQMessagePtr part(new FairMQMessageNN(size));
+                FairMQMessagePtr part(new FairMQMessageNN(size, GetTransport()));
                 static_cast<FairMQMessageNN*>(part.get())->fReceiving = true;
                 memcpy(part->GetData(), buf.data(), size);
                 msgVec.push_back(move(part));
@@ -377,15 +378,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)
@@ -432,12 +429,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;
 }
@@ -449,7 +441,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;
         }
     }
@@ -459,6 +451,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)
     {
@@ -468,6 +466,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)
     {
@@ -475,6 +486,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;
@@ -495,40 +573,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

@@ -14,31 +14,26 @@
 
 #include "FairMQSocket.h"
 #include "FairMQMessage.h"
+class FairMQTransportFactory;
 
-class FairMQSocketNN : public FairMQSocket
+class FairMQSocketNN final : public FairMQSocket
 {
   public:
-    FairMQSocketNN(const std::string& type, const std::string& name, const std::string& id = "");
+    FairMQSocketNN(const std::string& type, const std::string& name, const std::string& id = "", FairMQTransportFactory* fac = nullptr);
     FairMQSocketNN(const FairMQSocketNN&) = delete;
     FairMQSocketNN operator=(const FairMQSocketNN&) = delete;
 
     std::string GetId() override;
 
     bool Bind(const std::string& address) override;
-    void Connect(const std::string& address) override;
+    bool 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 +43,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 +75,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
+FairMQSocketPtr FairMQTransportFactoryNN::CreateSocket(const string& type, const string& name)
 {
-    return unique_ptr<FairMQSocket>(new FairMQSocketNN(type, name, GetId()));
+    unique_ptr<FairMQSocket> socket(new FairMQSocketNN(type, name, GetId(), this));
+    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;
+    FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) 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.cxx

@@ -138,11 +138,6 @@ auto Message::Copy(const fair::mq::Message& /*msg*/) -> void
     throw MessageError{"Not yet implemented."};
 }
 
-auto Message::Copy(const fair::mq::MessagePtr& /*msg*/) -> void
-{
-    throw MessageError{"Not yet implemented."};
-}
-
 Message::~Message()
 {
     if (fFreeFunction) {

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();
@@ -53,7 +53,6 @@ class Message : public fair::mq::Message
     auto GetType() const -> fair::mq::Transport override { return fair::mq::Transport::OFI; }
 
     auto Copy(const fair::mq::Message& msg) -> void override;
-    auto Copy(const fair::mq::MessagePtr& msg) -> void override;
 
     ~Message() override;
 

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);
     }
@@ -59,9 +60,8 @@ Poller::Poller(const vector<const FairMQChannel*>& channels)
 
 Poller::Poller(const unordered_map<string, vector<FairMQChannel>>& channelsMap, const vector<string>& channelList)
 {
-    int offset = 0;
-
     try {
+        int offset = 0;
         // calculate offsets and the total size of the poll item set
         for (string channel : channelList) {
             fOffsetMap[channel] = offset;
@@ -76,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);
             }
@@ -94,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

@@ -31,8 +31,9 @@ namespace ofi
 
 using namespace std;
 
-Socket::Socket(Context& context, const string& type, const string& name, const string& id /*= ""*/)
-    : fDataEndpoint(nullptr)
+Socket::Socket(Context& context, const string& type, const string& name, const string& id /*= ""*/, FairMQTransportFactory* fac)
+    : FairMQSocket{fac}
+    , fDataEndpoint(nullptr)
     , fDataCompletionQueueTx(nullptr)
     , fDataCompletionQueueRx(nullptr)
     , fId(id + "." + name + "." + type)
@@ -107,13 +108,14 @@ catch (const SocketError& e)
     return false;
 }
 
-auto Socket::Connect(const string& address) -> void
+auto Socket::Connect(const string& address) -> bool
 {
     auto addr = Context::VerifyAddress(address);
     ConnectControlSocket(addr);
     fContext.InitOfi(ConnectionType::Connect, addr);
     InitDataEndpoint();
     fWaitingForControlPeer = true;
+    return true;
 }
 
 auto Socket::BindControlSocket(Context::Address address) -> void
@@ -514,7 +516,7 @@ auto Socket::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int flags, cons
     //
     //     do
     //     {
-    //         FairMQMessagePtr part(new FairMQMessageSHM(fManager));
+    //         FairMQMessagePtr part(new FairMQMessageSHM(fManager, GetTransport()));
     //         zmq_msg_t* msgPtr = static_cast<FairMQMessageSHM*>(part.get())->GetMessage();
     //
     //         int nbytes = zmq_msg_recv(msgPtr, fSocket, flags);
@@ -619,114 +621,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

@@ -18,6 +18,7 @@
 #include <memory> // unique_ptr
 #include <netinet/in.h>
 #include <rdma/fabric.h>
+class FairMQTransportFactory;
 
 namespace fair
 {
@@ -32,17 +33,17 @@ 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 = "");
+    Socket(Context& factory, const std::string& type, const std::string& name, const std::string& id = "", FairMQTransportFactory* fac);
     Socket(const Socket&) = delete;
     Socket operator=(const Socket&) = delete;
 
     auto GetId() -> std::string { return fId; }
 
     auto Bind(const std::string& address) -> bool override;
-    auto Connect(const std::string& address) -> void override;
+    auto Connect(const std::string& address) -> bool override;
 
     auto Send(MessagePtr& msg, int timeout = 0) -> int override;
     auto Receive(MessagePtr& msg, int timeout = 0) -> int override;
@@ -54,8 +55,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 +78,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

@@ -56,9 +56,9 @@ auto TransportFactory::CreateMessage(UnmanagedRegionPtr& region, void* data, con
     return MessagePtr{new Message(region, data, size, hint)};
 }
 
-auto TransportFactory::CreateSocket(const string& type, const string& name) const -> SocketPtr
+auto TransportFactory::CreateSocket(const string& type, const string& name) -> SocketPtr
 {
-    return SocketPtr{new Socket(fContext, type, name, GetId())};
+    return SocketPtr{new Socket(fContext, type, name, GetId(), this)};
 }
 
 auto TransportFactory::CreatePoller(const vector<FairMQChannel>& channels) const -> PollerPtr
@@ -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);
@@ -38,12 +38,11 @@ class TransportFactory : public FairMQTransportFactory
     auto CreateMessage(void* data, const std::size_t size, fairmq_free_fn* ffn, void* hint = nullptr) const -> MessagePtr override;
     auto CreateMessage(UnmanagedRegionPtr& region, void* data, const std::size_t size, void* hint = nullptr) const -> MessagePtr override;
 
-    auto CreateSocket(const std::string& type, const std::string& name) const -> SocketPtr override;
+    auto CreateSocket(const std::string& type, const std::string& name) -> SocketPtr override;
 
     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

@@ -32,8 +32,7 @@ namespace parser
 // function that convert property tree (given the json structure) to FairMQChannelMap
 FairMQChannelMap ptreeToMQMap(const boost::property_tree::ptree& pt, const string& id, const string& rootNode)
 {
-    if (id == "")
-    {
+    if (id == "") {
         throw ParserError("no device ID provided. Provide with `--id` cmd option");
     }
 
@@ -44,8 +43,7 @@ FairMQChannelMap ptreeToMQMap(const boost::property_tree::ptree& pt, const strin
     // Extract value from boost::property_tree
     Helper::DeviceParser(pt.get_child(rootNode), channelMap, id);
 
-    if (channelMap.empty())
-    {
+    if (channelMap.empty()) {
         LOG(warn) << "---- No channel keys found for " << id;
         LOG(warn) << "---- Check the JSON inputs and/or command line inputs";
     }
@@ -68,20 +66,14 @@ void PrintDeviceList(const boost::property_tree::ptree& tree)
     string deviceIdKey;
 
     // do a first loop just to print the device-id in json input
-    for (const auto& p : tree)
-    {
-        if (p.first == "devices")
-        {
-            for (const auto& q : p.second.get_child(""))
-            {
+    for (const auto& p : tree) {
+        if (p.first == "devices") {
+            for (const auto& q : p.second.get_child("")) {
                 string key = q.second.get<string>("key", "");
-                if (key != "")
-                {
+                if (key != "") {
                     deviceIdKey = key;
                     LOG(debug) << "Found config for device key '" << deviceIdKey << "' in JSON input";
-                }
-                else
-                {
+                } else {
                     deviceIdKey = q.second.get<string>("id");
                     LOG(debug) << "Found config for device id '" << deviceIdKey << "' in JSON input";
                 }
@@ -95,33 +87,26 @@ void DeviceParser(const boost::property_tree::ptree& tree, FairMQChannelMap& cha
     string deviceIdKey;
 
     // For each node in fairMQOptions
-    for (const auto& p : tree)
-    {
-        if (p.first == "devices")
-        {
-            for (const auto& q : p.second)
-            {
+    for (const auto& p : tree) {
+        if (p.first == "devices") {
+            for (const auto& q : p.second) {
                 // check if key is provided, otherwise use id
                 string key = q.second.get<string>("key", "");
 
-                if (key != "")
-                {
+                if (key != "") {
                     deviceIdKey = key;
-                    // LOG(debug) << "Found config for device key '" << deviceIdKey << "' in JSON input";
-                }
-                else
-                {
+                    // LOG(trace) << "Found config for device key '" << deviceIdKey << "' in JSON input";
+                } else {
                     deviceIdKey = q.second.get<string>("id");
-                    // LOG(debug) << "Found config for device id '" << deviceIdKey << "' in JSON input";
+                    // LOG(trace) << "Found config for device id '" << deviceIdKey << "' in JSON input";
                 }
 
                 // if not correct device id, do not fill MQMap
-                if (deviceId != deviceIdKey)
-                {
+                if (deviceId != deviceIdKey) {
                     continue;
                 }
 
-                LOG(debug) << "Found following channels for device ID '" << deviceId << "' :";
+                LOG(trace) << "Found following channels for device ID '" << deviceId << "' :";
 
                 ChannelParser(q.second, channelMap);
             }
@@ -133,12 +118,9 @@ void ChannelParser(const boost::property_tree::ptree& tree, FairMQChannelMap& ch
 {
     string channelKey;
 
-    for (const auto& p : tree)
-    {
-        if (p.first == "channels")
-        {
-            for (const auto& q : p.second)
-            {
+    for (const auto& p : tree) {
+        if (p.first == "channels") {
+            for (const auto& q : p.second) {
                 channelKey = q.second.get<string>("name");
 
                 int numSockets = q.second.get<int>("numSockets", 0);
@@ -153,35 +135,39 @@ 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()));
+                commonChannel.UpdatePortRangeMin(q.second.get<int>("portRangeMin", commonChannel.GetPortRangeMin()));
+                commonChannel.UpdatePortRangeMax(q.second.get<int>("portRangeMax", commonChannel.GetPortRangeMax()));
+                commonChannel.UpdateAutoBind(q.second.get<bool>("autoBind", commonChannel.GetAutoBind()));
 
                 // temporary FairMQChannel container
                 vector<FairMQChannel> channelList;
 
-                if (numSockets > 0)
-                {
-                    LOG(debug) << "" << channelKey << ":";
-                    LOG(debug) << "\tnumSockets of " << numSockets << " specified,";
-                    LOG(debug) << "\tapplying common settings to each:";
+                if (numSockets > 0) {
+                    LOG(trace) << "" << channelKey << ":";
+                    LOG(trace) << "\tnumSockets of " << numSockets << " specified,";
+                    LOG(trace) << "\tapplying common settings to each:";
 
-                    LOG(debug) << "\ttype          = " << commonChannel.GetType();
-                    LOG(debug) << "\tmethod        = " << commonChannel.GetMethod();
-                    LOG(debug) << "\taddress       = " << commonChannel.GetAddress();
-                    LOG(debug) << "\ttransport     = " << commonChannel.GetTransportName();
-                    LOG(debug) << "\tsndBufSize    = " << commonChannel.GetSndBufSize();
-                    LOG(debug) << "\trcvBufSize    = " << commonChannel.GetRcvBufSize();
-                    LOG(debug) << "\tsndKernelSize = " << commonChannel.GetSndKernelSize();
-                    LOG(debug) << "\trcvKernelSize = " << commonChannel.GetRcvKernelSize();
-                    LOG(debug) << "\trateLogging   = " << commonChannel.GetRateLogging();
+                    LOG(trace) << "\ttype          = " << commonChannel.GetType();
+                    LOG(trace) << "\tmethod        = " << commonChannel.GetMethod();
+                    LOG(trace) << "\taddress       = " << commonChannel.GetAddress();
+                    LOG(trace) << "\ttransport     = " << commonChannel.GetTransportName();
+                    LOG(trace) << "\tsndBufSize    = " << commonChannel.GetSndBufSize();
+                    LOG(trace) << "\trcvBufSize    = " << commonChannel.GetRcvBufSize();
+                    LOG(trace) << "\tsndKernelSize = " << commonChannel.GetSndKernelSize();
+                    LOG(trace) << "\trcvKernelSize = " << commonChannel.GetRcvKernelSize();
+                    LOG(trace) << "\tlinger        = " << commonChannel.GetLinger();
+                    LOG(trace) << "\trateLogging   = " << commonChannel.GetRateLogging();
+                    LOG(trace) << "\tportRangeMin  = " << commonChannel.GetPortRangeMin();
+                    LOG(trace) << "\tportRangeMax  = " << commonChannel.GetPortRangeMax();
+                    LOG(trace) << "\tautoBind      = " << commonChannel.GetAutoBind();
 
-                    for (int i = 0; i < numSockets; ++i)
-                    {
+                    for (int i = 0; i < numSockets; ++i) {
                         FairMQChannel channel(commonChannel);
                         channelList.push_back(channel);
                     }
-                }
-                else
-                {
+                } else {
                     SocketParser(q.second.get_child(""), channelList, channelKey, commonChannel);
                 }
 
@@ -196,12 +182,9 @@ void SocketParser(const boost::property_tree::ptree& tree, vector<FairMQChannel>
     // for each socket in channel
     int socketCounter = 0;
 
-    for (const auto& p : tree)
-    {
-        if (p.first == "sockets")
-        {
-            for (const auto& q : p.second)
-            {
+    for (const auto& p : tree) {
+        if (p.first == "sockets") {
+            for (const auto& q : p.second) {
                 // create new channel and apply setting from the common channel
                 FairMQChannel channel(commonChannel);
 
@@ -214,18 +197,26 @@ 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()));
+                channel.UpdatePortRangeMin(q.second.get<int>("portRangeMin", channel.GetPortRangeMin()));
+                channel.UpdatePortRangeMax(q.second.get<int>("portRangeMax", channel.GetPortRangeMax()));
+                channel.UpdateAutoBind(q.second.get<bool>("autoBind", channel.GetAutoBind()));
 
-                LOG(debug) << "" << channelName << "[" << socketCounter << "]:";
-                LOG(debug) << "\ttype          = " << channel.GetType();
-                LOG(debug) << "\tmethod        = " << channel.GetMethod();
-                LOG(debug) << "\taddress       = " << channel.GetAddress();
-                LOG(debug) << "\ttransport     = " << channel.GetTransportName();
-                LOG(debug) << "\tsndBufSize    = " << channel.GetSndBufSize();
-                LOG(debug) << "\trcvBufSize    = " << channel.GetRcvBufSize();
-                LOG(debug) << "\tsndKernelSize = " << channel.GetSndKernelSize();
-                LOG(debug) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
-                LOG(debug) << "\trateLogging   = " << channel.GetRateLogging();
+                LOG(trace) << "" << channelName << "[" << socketCounter << "]:";
+                LOG(trace) << "\ttype          = " << channel.GetType();
+                LOG(trace) << "\tmethod        = " << channel.GetMethod();
+                LOG(trace) << "\taddress       = " << channel.GetAddress();
+                LOG(trace) << "\ttransport     = " << channel.GetTransportName();
+                LOG(trace) << "\tsndBufSize    = " << channel.GetSndBufSize();
+                LOG(trace) << "\trcvBufSize    = " << channel.GetRcvBufSize();
+                LOG(trace) << "\tsndKernelSize = " << channel.GetSndKernelSize();
+                LOG(trace) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
+                LOG(trace) << "\tlinger        = " << channel.GetLinger();
+                LOG(trace) << "\trateLogging   = " << channel.GetRateLogging();
+                LOG(trace) << "\tportRangeMin  = " << channel.GetPortRangeMin();
+                LOG(trace) << "\tportRangeMax  = " << channel.GetPortRangeMax();
+                LOG(trace) << "\tautoBind      = " << channel.GetAutoBind();
 
                 channelList.push_back(channel);
                 ++socketCounter;
@@ -233,27 +224,28 @@ void SocketParser(const boost::property_tree::ptree& tree, vector<FairMQChannel>
         }
     } // end socket loop
 
-    if (socketCounter)
-    {
-        LOG(debug) << "Found " << socketCounter << " socket(s) in channel.";
-    }
-    else
-    {
-        LOG(debug) << "" << channelName << ":";
-        LOG(debug) << "\tNo sockets specified,";
-        LOG(debug) << "\tapplying common settings to the channel:";
+    if (socketCounter) {
+        LOG(trace) << "Found " << socketCounter << " socket(s) in channel.";
+    } else {
+        LOG(trace) << "" << channelName << ":";
+        LOG(trace) << "\tNo sockets specified,";
+        LOG(trace) << "\tapplying common settings to the channel:";
 
         FairMQChannel channel(commonChannel);
 
-        LOG(debug) << "\ttype          = " << channel.GetType();
-        LOG(debug) << "\tmethod        = " << channel.GetMethod();
-        LOG(debug) << "\taddress       = " << channel.GetAddress();
-        LOG(debug) << "\ttransport     = " << channel.GetTransportName();
-        LOG(debug) << "\tsndBufSize    = " << channel.GetSndBufSize();
-        LOG(debug) << "\trcvBufSize    = " << channel.GetRcvBufSize();
-        LOG(debug) << "\tsndKernelSize = " << channel.GetSndKernelSize();
-        LOG(debug) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
-        LOG(debug) << "\trateLogging   = " << channel.GetRateLogging();
+        LOG(trace) << "\ttype          = " << channel.GetType();
+        LOG(trace) << "\tmethod        = " << channel.GetMethod();
+        LOG(trace) << "\taddress       = " << channel.GetAddress();
+        LOG(trace) << "\ttransport     = " << channel.GetTransportName();
+        LOG(trace) << "\tsndBufSize    = " << channel.GetSndBufSize();
+        LOG(trace) << "\trcvBufSize    = " << channel.GetRcvBufSize();
+        LOG(trace) << "\tsndKernelSize = " << channel.GetSndKernelSize();
+        LOG(trace) << "\trcvKernelSize = " << channel.GetRcvKernelSize();
+        LOG(trace) << "\tlinger        = " << channel.GetLinger();
+        LOG(trace) << "\trateLogging   = " << channel.GetRateLogging();
+        LOG(trace) << "\tportRangeMin  = " << channel.GetPortRangeMin();
+        LOG(trace) << "\tportRangeMax  = " << channel.GetPortRangeMax();
+        LOG(trace) << "\tautoBind      = " << channel.GetAutoBind();
 
         channelList.push_back(channel);
     }

fairmq/options/FairMQProgOptions.cxx

@@ -19,10 +19,9 @@
 #include "FairMQParser.h"
 #include "FairMQSuboptParser.h"
 
+#include "tools/Unique.h"
+
 #include <boost/algorithm/string.hpp> // join/split
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid_io.hpp>
 
 #include <algorithm>
 #include <iomanip>
@@ -63,8 +62,6 @@ FairMQProgOptions::FairMQProgOptions()
         ("network-interface",      po::value<string>()->default_value("default"),  "Network interface to bind on (e.g. eth0, ib0..., default will try to detect the interface of the default route).")
         ("config-key",             po::value<string>(),                            "Use provided value instead of device id for fetching the configuration from the config file.")
         ("initialization-timeout", po::value<int   >()->default_value(120),        "Timeout for the initialization in seconds (when expecting dynamic initialization).")
-        ("port-range-min",         po::value<int   >()->default_value(22000),      "Start of the port range for dynamic initialization.")
-        ("port-range-max",         po::value<int   >()->default_value(32000),      "End of the port range for dynamic initialization.")
         ("print-channels",         po::value<bool  >()->implicit_value(true),      "Print registered channel endpoints in a machine-readable format (<channel name>:<min num subchannels>:<max num subchannels>)")
         ("shm-segment-size",       po::value<size_t>()->default_value(2000000000), "Shared memory: size of the shared memory segment (in bytes).")
         ("shm-monitor",            po::value<bool  >()->default_value(true),       "Shared memory: run monitor daemon.")
@@ -162,7 +159,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
         {
@@ -171,7 +168,6 @@ int FairMQProgOptions::ParseAll(const int argc, char const* const* argv, bool al
             {
                 LOG(warn) << "--" << p->canonical_display_name();
             }
-            LOG(warn) << "No channels will be created (You can create them manually).";
         }
     }
     catch (exception& e)
@@ -185,6 +181,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();
@@ -210,7 +223,7 @@ void FairMQProgOptions::ParseCmdLine(const int argc, char const* const* argv, bo
 
 void FairMQProgOptions::ParseDefaults()
 {
-    vector<string> emptyArgs = {"dummy", "--id", boost::uuids::to_string(boost::uuids::random_generator()())};
+    vector<string> emptyArgs = {"dummy", "--id", tools::Uuid()};
 
     vector<const char*> argv(emptyArgs.size());
 
@@ -254,12 +267,10 @@ void FairMQProgOptions::UpdateChannelInfo()
 // create key for variable map as follow : channelName.index.memberName
 void FairMQProgOptions::UpdateMQValues()
 {
-    for (const auto& p : fFairMQChannelMap)
-    {
+    for (const auto& p : fFairMQChannelMap) {
         int index = 0;
 
-        for (const auto& channel : p.second)
-        {
+        for (const auto& channel : p.second) {
             string typeKey = "chans." + p.first + "." + to_string(index) + ".type";
             string methodKey = "chans." + p.first + "." + to_string(index) + ".method";
             string addressKey = "chans." + p.first + "." + to_string(index) + ".address";
@@ -268,7 +279,11 @@ 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";
+            string portRangeMinKey = "chans." + p.first + "." + to_string(index) + ".portRangeMin";
+            string portRangeMaxKey = "chans." + p.first + "." + to_string(index) + ".portRangeMax";
+            string autoBindKey = "chans." + p.first + "." + to_string(index) + ".autoBind";
 
             fChannelKeyMap[typeKey] = ChannelKey{p.first, index, "type"};
             fChannelKeyMap[methodKey] = ChannelKey{p.first, index, "method"};
@@ -278,7 +293,11 @@ 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"};
+            fChannelKeyMap[portRangeMinKey] = ChannelKey{p.first, index, "portRangeMin"};
+            fChannelKeyMap[portRangeMaxKey] = ChannelKey{p.first, index, "portRangeMax"};
+            fChannelKeyMap[autoBindKey] = ChannelKey{p.first, index, "autoBind"};
 
             UpdateVarMap<string>(typeKey, channel.GetType());
             UpdateVarMap<string>(methodKey, channel.GetMethod());
@@ -288,69 +307,69 @@ 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());
+            UpdateVarMap<int>(portRangeMinKey, channel.GetPortRangeMin());
+            UpdateVarMap<int>(portRangeMaxKey, channel.GetPortRangeMax());
+            UpdateVarMap<bool>(autoBindKey, channel.GetAutoBind());
 
             index++;
         }
+
         UpdateVarMap<int>("chans." + p.first + ".numSockets", index);
     }
 }
 
 int FairMQProgOptions::UpdateChannelValue(const string& channelName, int index, const string& member, const string& val)
 {
-    if (member == "type")
-    {
+    if (member == "type") {
         fFairMQChannelMap.at(channelName).at(index).UpdateType(val);
-        return 0;
-    }
-
-    if (member == "method")
-    {
+    } else if (member == "method") {
         fFairMQChannelMap.at(channelName).at(index).UpdateMethod(val);
-        return 0;
-    }
-
-    if (member == "address")
-    {
+    } else if (member == "address") {
         fFairMQChannelMap.at(channelName).at(index).UpdateAddress(val);
-        return 0;
-    }
-
-    if (member == "transport")
-    {
+    } else if (member == "transport") {
         fFairMQChannelMap.at(channelName).at(index).UpdateTransport(val);
-        return 0;
-    }
-    else
-    {
-        //if we get there it means something is wrong
+    } else {
         LOG(error)  << "update of FairMQChannel map failed for the following key: " << channelName << "." << index << "." << member;
         return 1;
     }
+
+    return 0;
 }
 
 int FairMQProgOptions::UpdateChannelValue(const string& channelName, int index, const string& member, int val)
 {
-    if (member == "sndBufSize")
-    {
+    if (member == "sndBufSize") {
         fFairMQChannelMap.at(channelName).at(index).UpdateSndBufSize(val);
-        return 0;
-    }
-
-    if (member == "rcvBufSize")
-    {
+    } else if (member == "rcvBufSize") {
         fFairMQChannelMap.at(channelName).at(index).UpdateRcvBufSize(val);
-        return 0;
+    } else if (member == "sndKernelSize") {
+        fFairMQChannelMap.at(channelName).at(index).UpdateSndKernelSize(val);
+    } else if (member == "rcvKernelSize") {
+        fFairMQChannelMap.at(channelName).at(index).UpdateRcvKernelSize(val);
+    } else if (member == "linger") {
+        fFairMQChannelMap.at(channelName).at(index).UpdateLinger(val);
+    } else if (member == "rateLogging") {
+        fFairMQChannelMap.at(channelName).at(index).UpdateRateLogging(val);
+    } else if (member == "portRangeMin") {
+        fFairMQChannelMap.at(channelName).at(index).UpdatePortRangeMin(val);
+    } else if (member == "portRangeMax") {
+        fFairMQChannelMap.at(channelName).at(index).UpdatePortRangeMax(val);
+    } else {
+        LOG(error)  << "update of FairMQChannel map failed for the following key: " << channelName << "." << index << "." << member;
+        return 1;
     }
 
-    if (member == "rateLogging")
-    {
-        fFairMQChannelMap.at(channelName).at(index).UpdateRateLogging(val);
+    return 0;
+}
+
+int FairMQProgOptions::UpdateChannelValue(const string& channelName, int index, const string& member, bool val)
+{
+    if (member == "autoBind") {
+        fFairMQChannelMap.at(channelName).at(index).UpdateAutoBind(val);
         return 0;
-    }
-    else
-    {
-        // if we get there it means something is wrong
+    } else {
         LOG(error)  << "update of FairMQChannel map failed for the following key: " << channelName << "." << index << "." << member;
         return 1;
     }

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,8 +210,15 @@ 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);
+    int UpdateChannelValue(const std::string& channelName, int index, const std::string& member, bool val);
 
     void UpdateChannelInfo();
 
@@ -223,6 +230,7 @@ class FairMQProgOptions
         vm[key].value() = boost::any(val);
     }
 
+    void ParseChannelsFromCmdLine();
 };
 
 #endif /* FAIRMQPROGOPTIONS_H */

fairmq/options/FairMQSuboptParser.h

@@ -56,7 +56,11 @@ struct SUBOPT
         RCVBUFSIZE,     // size of the receive queue
         SNDKERNELSIZE,
         RCVKERNELSIZE,
+        LINGER,
         RATELOGGING,    // logging rate
+        PORTRANGEMIN,
+        PORTRANGEMAX,
+        AUTOBIND,
         NUMSOCKETS,
         lastsocketkey
     };
@@ -71,7 +75,11 @@ struct SUBOPT
         /*[RCVBUFSIZE]    = */ "rcvBufSize",
         /*[SNDKERNELSIZE] = */ "sndKernelSize",
         /*[RCVKERNELSIZE] = */ "rcvKernelSize",
+        /*[LINGER]        = */ "linger",
         /*[RATELOGGING]   = */ "rateLogging",
+        /*[PORTRANGEMIN]  = */ "portRangeMin",
+        /*[PORTRANGEMAX]  = */ "portRangeMax",
+        /*[AUTOBIND]      = */ "autoBind",
         /*[NUMSOCKETS]    = */ "numSockets",
         nullptr
     };

fairmq/plugins/Control.cxx

@@ -1,5 +1,5 @@
 /********************************************************************************
- *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2017-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -11,17 +11,26 @@
 #include <termios.h> // for the interactive mode
 #include <poll.h> // for the interactive mode
 #include <csignal> // catching system signals
+#include <cstdlib>
 #include <functional>
+#include <atomic>
 
 using namespace std;
 
 namespace
 {
-    volatile sig_atomic_t gSignalStatus = 0;
+    std::atomic<sig_atomic_t> gLastSignal(0);
+    std::atomic<int> gSignalCount(0);
 
     extern "C" auto signal_handler(int signal) -> void
     {
-        gSignalStatus = signal;
+        ++gSignalCount;
+        gLastSignal = signal;
+
+        if (gSignalCount > 1)
+        {
+            std::abort();
+        }
     }
 }
 
@@ -32,18 +41,27 @@ namespace mq
 namespace plugins
 {
 
-Control::Control(const string name, const Plugin::Version version, const string maintainer, const string homepage, PluginServices* pluginServices)
+Control::Control(const string& name, const Plugin::Version version, const string& maintainer, const string& homepage, PluginServices* pluginServices)
     : Plugin(name, version, maintainer, homepage, pluginServices)
     , fControllerThread()
     , fSignalHandlerThread()
-    , fShutdownThread()
     , fEvents()
     , fEventsMutex()
-    , fShutdownMutex()
+    , fControllerMutex()
     , fNewEvent()
-    , fDeviceTerminationRequested(false)
-    , fHasShutdown(false)
+    , fDeviceShutdownRequested(false)
+    , fDeviceHasShutdown(false)
+    , fPluginShutdownRequested(false)
 {
+    SubscribeToDeviceStateChange([&](DeviceState newState)
+    {
+        {
+            lock_guard<mutex> lock{fEventsMutex};
+            fEvents.push(newState);
+        }
+        fNewEvent.notify_one();
+    });
+
     try
     {
         TakeDeviceControl();
@@ -95,124 +113,140 @@ auto ControlPluginProgramOptions() -> Plugin::ProgOptions
     return pluginOptions;
 }
 
-auto Control::InteractiveMode() -> void
+struct terminal_config
 {
-    try
+    terminal_config()
     {
-        RunStartupSequence();
-
-        char input; // hold the user console input
-        pollfd cinfd[1];
-        cinfd[0].fd = fileno(stdin);
-        cinfd[0].events = POLLIN;
-
-        struct termios t;
+        termios t;
         tcgetattr(STDIN_FILENO, &t); // get the current terminal I/O structure
         t.c_lflag &= ~ICANON; // disable canonical input
         t.c_lflag &= ~ECHO; // do not echo input chars
         tcsetattr(STDIN_FILENO, TCSANOW, &t); // apply the new settings
+    }
 
-        PrintInteractiveHelp();
-
-        bool keepRunning = true;
-
-        while (keepRunning)
-        {
-            if (poll(cinfd, 1, 500))
-            {
-                if (fDeviceTerminationRequested)
-                {
-                    break;
-                }
-
-                cin >> input;
-
-                switch (input)
-                {
-                    case 'i':
-                        LOG(info) << "\n\n --> [i] init device\n";
-                        ChangeDeviceState(DeviceStateTransition::InitDevice);
-                    break;
-                    case 'j':
-                        LOG(info) << "\n\n --> [j] init task\n";
-                        ChangeDeviceState(DeviceStateTransition::InitTask);
-                    break;
-                    case 'p':
-                        LOG(info) << "\n\n --> [p] pause\n";
-                        ChangeDeviceState(DeviceStateTransition::Pause);
-                    break;
-                    case 'r':
-                        LOG(info) << "\n\n --> [r] run\n";
-                        ChangeDeviceState(DeviceStateTransition::Run);
-                    break;
-                    case 's':
-                        LOG(info) << "\n\n --> [s] stop\n";
-                        ChangeDeviceState(DeviceStateTransition::Stop);
-                    break;
-                    case 't':
-                        LOG(info) << "\n\n --> [t] reset task\n";
-                        ChangeDeviceState(DeviceStateTransition::ResetTask);
-                    break;
-                    case 'd':
-                        LOG(info) << "\n\n --> [d] reset device\n";
-                        ChangeDeviceState(DeviceStateTransition::ResetDevice);
-                    break;
-                    case 'k':
-                        LOG(info) << "\n\n --> [k] increase log severity\n";
-                        CycleLogConsoleSeverityUp();
-                    break;
-                    case 'l':
-                        LOG(info) << "\n\n --> [l] decrease log severity\n";
-                        CycleLogConsoleSeverityDown();
-                    break;
-                    case 'n':
-                        LOG(info) << "\n\n --> [n] increase log verbosity\n";
-                        CycleLogVerbosityUp();
-                    break;
-                    case 'm':
-                        LOG(info) << "\n\n --> [m] decrease log verbosity\n";
-                        CycleLogVerbosityDown();
-                    break;
-                    case 'h':
-                        LOG(info) << "\n\n --> [h] help\n";
-                        PrintInteractiveHelp();
-                    break;
-                    // case 'x':
-                    //     LOG(info) << "\n\n --> [x] ERROR\n";
-                    //     ChangeDeviceState(DeviceStateTransition::ERROR_FOUND);
-                    //     break;
-                    case 'q':
-                        LOG(info) << "\n\n --> [q] end\n";
-                        keepRunning = false;
-                    break;
-                    default:
-                        LOG(info) << "Invalid input: [" << input << "]";
-                        PrintInteractiveHelp();
-                    break;
-                }
-            }
-
-            if (fDeviceTerminationRequested)
-            {
-                keepRunning = false;
-            }
-        }
-
+    ~terminal_config()
+    {
+        termios t;
         tcgetattr(STDIN_FILENO, &t); // get the current terminal I/O structure
         t.c_lflag |= ICANON; // re-enable canonical input
         t.c_lflag |= ECHO; // echo input chars
         tcsetattr(STDIN_FILENO, TCSANOW, &t); // apply the new settings
+    }
+};
 
-        if (!fDeviceTerminationRequested)
+auto Control::InteractiveMode() -> void
+try
+{
+    RunStartupSequence();
+
+    char input; // hold the user console input
+    pollfd cinfd[1];
+    cinfd[0].fd = fileno(stdin);
+    cinfd[0].events = POLLIN;
+    cinfd[0].revents = 0;
+
+    terminal_config tconfig;
+
+    PrintInteractiveHelp();
+
+    bool keepRunning = true;
+
+    while (keepRunning)
+    {
+        if (poll(cinfd, 1, 500))
         {
-            RunShutdownSequence();
+            if (fDeviceShutdownRequested)
+            {
+                break;
+            }
+
+            cin >> input;
+
+            switch (input)
+            {
+                case 'i':
+                    LOG(info) << "\n\n --> [i] init device\n";
+                    ChangeDeviceState(DeviceStateTransition::InitDevice);
+                break;
+                case 'j':
+                    LOG(info) << "\n\n --> [j] init task\n";
+                    ChangeDeviceState(DeviceStateTransition::InitTask);
+                break;
+                case 'p':
+                    LOG(info) << "\n\n --> [p] pause\n";
+                    ChangeDeviceState(DeviceStateTransition::Pause);
+                break;
+                case 'r':
+                    LOG(info) << "\n\n --> [r] run\n";
+                    ChangeDeviceState(DeviceStateTransition::Run);
+                break;
+                case 's':
+                    LOG(info) << "\n\n --> [s] stop\n";
+                    ChangeDeviceState(DeviceStateTransition::Stop);
+                break;
+                case 't':
+                    LOG(info) << "\n\n --> [t] reset task\n";
+                    ChangeDeviceState(DeviceStateTransition::ResetTask);
+                break;
+                case 'd':
+                    LOG(info) << "\n\n --> [d] reset device\n";
+                    ChangeDeviceState(DeviceStateTransition::ResetDevice);
+                break;
+                case 'k':
+                    LOG(info) << "\n\n --> [k] increase log severity\n";
+                    CycleLogConsoleSeverityUp();
+                break;
+                case 'l':
+                    LOG(info) << "\n\n --> [l] decrease log severity\n";
+                    CycleLogConsoleSeverityDown();
+                break;
+                case 'n':
+                    LOG(info) << "\n\n --> [n] increase log verbosity\n";
+                    CycleLogVerbosityUp();
+                break;
+                case 'm':
+                    LOG(info) << "\n\n --> [m] decrease log verbosity\n";
+                    CycleLogVerbosityDown();
+                break;
+                case 'h':
+                    LOG(info) << "\n\n --> [h] help\n";
+                    PrintInteractiveHelp();
+                break;
+                // case 'x':
+                //     LOG(info) << "\n\n --> [x] ERROR\n";
+                //     ChangeDeviceState(DeviceStateTransition::ERROR_FOUND);
+                //     break;
+                case 'q':
+                    LOG(info) << "\n\n --> [q] end\n";
+                    keepRunning = false;
+                break;
+                default:
+                    LOG(info) << "Invalid input: [" << input << "]";
+                    PrintInteractiveHelp();
+                break;
+            }
+        }
+
+        if (GetCurrentDeviceState() == DeviceState::Error)
+        {
+            throw DeviceErrorState("Controlled device transitioned to error state.");
+        }
+
+        if (fDeviceShutdownRequested)
+        {
+            break;
         }
     }
-    catch (PluginServices::DeviceControlError& e)
-    {
-        // If we are here, it means another plugin has taken control. That's fine, just print the exception message and do nothing else.
-        LOG(debug) << e.what();
-    }
+
+    RunShutdownSequence();
+}
+catch (PluginServices::DeviceControlError& e)
+{
+    // If we are here, it means another plugin has taken control. That's fine, just print the exception message and do nothing else.
+    LOG(debug) << e.what();
+}
+catch (DeviceErrorState&)
+{
 }
 
 auto Control::PrintInteractiveHelp() -> void
@@ -233,137 +267,124 @@ auto Control::WaitForNextState() -> DeviceState
     }
 
     auto result = fEvents.front();
+
+    if (result == DeviceState::Error)
+    {
+        throw DeviceErrorState("Controlled device transitioned to error state.");
+    }
+
     fEvents.pop();
+
     return result;
 }
 
 auto Control::StaticMode() -> void
+try
 {
-    try
-    {
-        RunStartupSequence();
+    RunStartupSequence();
 
+    {
+        // Wait for next state, which is DeviceState::Ready,
+        // or for device shutdown request (Ctrl-C)
+        unique_lock<mutex> lock{fEventsMutex};
+        while (fEvents.empty() && !fDeviceShutdownRequested)
         {
-            // Wait for next state, which is DeviceState::Ready,
-            // or for device termination request
-            unique_lock<mutex> lock{fEventsMutex};
-            while (fEvents.empty() && !fDeviceTerminationRequested)
-            {
-                fNewEvent.wait(lock);
-            }
+            fNewEvent.wait_for(lock, chrono::milliseconds(50));
         }
 
-        if (!fDeviceTerminationRequested)
+        if (fEvents.front() == DeviceState::Error)
         {
-            RunShutdownSequence();
+            throw DeviceErrorState("Controlled device transitioned to error state.");
         }
     }
-    catch (PluginServices::DeviceControlError& e)
-    {
-        // If we are here, it means another plugin has taken control. That's fine, just print the exception message and do nothing else.
-        LOG(debug) << e.what();
-    }
+
+    RunShutdownSequence();
+}
+catch (PluginServices::DeviceControlError& e)
+{
+    // If we are here, it means another plugin has taken control. That's fine, just print the exception message and do nothing else.
+    LOG(debug) << e.what();
+}
+catch (DeviceErrorState&)
+{
 }
 
 auto Control::SignalHandler() -> void
 {
-    while (true)
+    while (gSignalCount == 0 && !fPluginShutdownRequested)
     {
-        if (gSignalStatus != 0 && !fHasShutdown)
-        {
-            LOG(info) << "Received device shutdown request (signal " << gSignalStatus << ").";
-            LOG(info) << "Waiting for graceful device shutdown. Hit Ctrl-C again to abort immediately.";
-
-            if (!fDeviceTerminationRequested)
-            {
-                fDeviceTerminationRequested = true;
-                gSignalStatus = 0;
-                fShutdownThread = thread(&Control::HandleShutdownSignal, this);
-            }
-            else
-            {
-                LOG(warn) << "Received 2nd device shutdown request (signal " << gSignalStatus << ").";
-                LOG(warn) << "Aborting immediately!";
-                abort();
-            }
-        }
-        else if (fHasShutdown)
-        {
-            break;
-        }
-
         this_thread::sleep_for(chrono::milliseconds(100));
     }
-}
 
-auto Control::HandleShutdownSignal() -> void
-{
-    StealDeviceControl();
-
-    UnsubscribeFromDeviceStateChange(); // In case, static or interactive mode have subscribed already
-    SubscribeToDeviceStateChange([&](DeviceState newState)
+    if (!fPluginShutdownRequested)
     {
-        {
-            lock_guard<mutex> lock{fEventsMutex};
-            fEvents.push(newState);
-        }
-        fNewEvent.notify_one();
-    });
+        LOG(info) << "Received device shutdown request (signal " << gLastSignal << ").";
+        LOG(info) << "Waiting for graceful device shutdown. Hit Ctrl-C again to abort immediately.";
 
-    RunShutdownSequence();
+        // Signal and wait for controller thread, if we are controller
+        fDeviceShutdownRequested = true;
+        {
+            unique_lock<mutex> lock(fControllerMutex);
+            if (fControllerThread.joinable()) fControllerThread.join();
+        }
+
+        if (!fDeviceHasShutdown)
+        {
+            // Take over control and attempt graceful shutdown
+            StealDeviceControl();
+            try
+            {
+                RunShutdownSequence();
+            }
+            catch (PluginServices::DeviceControlError& e)
+            {
+                LOG(info) << "Graceful device shutdown failed: " << e.what() << " If hanging, hit Ctrl-C again to abort immediately.";
+            }
+            catch (...)
+            {
+                LOG(info) << "Graceful device shutdown failed. If hanging, hit Ctrl-C again to abort immediately.";
+            }
+        }
+    }
 }
 
 auto Control::RunShutdownSequence() -> void
 {
-    lock_guard<mutex> lock(fShutdownMutex);
-    if (!fHasShutdown)
+    auto nextState = GetCurrentDeviceState();
+    EmptyEventQueue();
+    while (nextState != DeviceState::Exiting && nextState != DeviceState::Error)
     {
-        auto nextState = GetCurrentDeviceState();
-        EmptyEventQueue();
-        while (nextState != DeviceState::Exiting)
+        switch (nextState)
         {
-            switch (nextState)
-            {
-                case DeviceState::Idle:
-                    ChangeDeviceState(DeviceStateTransition::End);
-                    break;
-                case DeviceState::DeviceReady:
-                    ChangeDeviceState(DeviceStateTransition::ResetDevice);
-                    break;
-                case DeviceState::Ready:
-                    ChangeDeviceState(DeviceStateTransition::ResetTask);
-                    break;
-                case DeviceState::Running:
-                    ChangeDeviceState(DeviceStateTransition::Stop);
-                    break;
-                case DeviceState::Paused:
-                    ChangeDeviceState(DeviceStateTransition::Resume);
-                    break;
-                default:
-                    // ignore other states
-                    break;
-            }
-
-            nextState = WaitForNextState();
+            case DeviceState::Idle:
+                ChangeDeviceState(DeviceStateTransition::End);
+                break;
+            case DeviceState::DeviceReady:
+                ChangeDeviceState(DeviceStateTransition::ResetDevice);
+                break;
+            case DeviceState::Ready:
+                ChangeDeviceState(DeviceStateTransition::ResetTask);
+                break;
+            case DeviceState::Running:
+                ChangeDeviceState(DeviceStateTransition::Stop);
+                break;
+            case DeviceState::Paused:
+                ChangeDeviceState(DeviceStateTransition::Resume);
+                break;
+            default:
+                LOG(debug) << "Controller ignoring event: " << nextState;
+                break;
         }
 
-        fHasShutdown = true;
-        UnsubscribeFromDeviceStateChange();
-        ReleaseDeviceControl();
+        nextState = WaitForNextState();
     }
+
+    fDeviceHasShutdown = true;
+    ReleaseDeviceControl();
 }
 
 auto Control::RunStartupSequence() -> void
 {
-    SubscribeToDeviceStateChange([&](DeviceState newState)
-    {
-        {
-            lock_guard<mutex> lock{fEventsMutex};
-            fEvents.push(newState);
-        }
-        fNewEvent.notify_one();
-    });
-
     ChangeDeviceState(DeviceStateTransition::InitDevice);
     while (WaitForNextState() != DeviceState::DeviceReady) {}
     ChangeDeviceState(DeviceStateTransition::InitTask);
@@ -380,9 +401,16 @@ auto Control::EmptyEventQueue() -> void
 
 Control::~Control()
 {
-    if (fControllerThread.joinable()) fControllerThread.join();
+    // Notify threads to exit
+    fPluginShutdownRequested = true;
+
+    {
+        unique_lock<mutex> lock(fControllerMutex);
+        if (fControllerThread.joinable()) fControllerThread.join();
+    }
     if (fSignalHandlerThread.joinable()) fSignalHandlerThread.join();
-    if (fShutdownThread.joinable()) fShutdownThread.join();
+
+    UnsubscribeFromDeviceStateChange();
 }
 
 } /* namespace plugins */

fairmq/plugins/Control.h

@@ -10,6 +10,7 @@
 #define FAIR_MQ_PLUGINS_CONTROL
 
 #include <fairmq/Plugin.h>
+#include <fairmq/Version.h>
 
 #include <condition_variable>
 #include <mutex>
@@ -17,6 +18,7 @@
 #include <queue>
 #include <thread>
 #include <atomic>
+#include <stdexcept>
 
 namespace fair
 {
@@ -28,42 +30,46 @@ namespace plugins
 class Control : public Plugin
 {
   public:
-    Control(const std::string name, const Plugin::Version version, const std::string maintainer, const std::string homepage, PluginServices* pluginServices);
+    Control(const std::string& name, const Plugin::Version version, const std::string& maintainer, const std::string& homepage, PluginServices* pluginServices);
 
     ~Control();
 
   private:
     auto InteractiveMode() -> void;
-    auto PrintInteractiveHelp() -> void;
+    static auto PrintInteractiveHelp() -> void;
     auto StaticMode() -> void;
     auto WaitForNextState() -> DeviceState;
     auto SignalHandler() -> void;
-    auto HandleShutdownSignal() -> void;
     auto RunShutdownSequence() -> void;
     auto RunStartupSequence() -> void;
     auto EmptyEventQueue() -> void;
 
     std::thread fControllerThread;
     std::thread fSignalHandlerThread;
-    std::thread fShutdownThread;
     std::queue<DeviceState> fEvents;
     std::mutex fEventsMutex;
-    std::mutex fShutdownMutex;
+    std::mutex fControllerMutex;
     std::condition_variable fNewEvent;
-    std::atomic<bool> fDeviceTerminationRequested;
-    std::atomic<bool> fHasShutdown;
+    std::atomic<bool> fDeviceShutdownRequested;
+    std::atomic<bool> fDeviceHasShutdown;
+    std::atomic<bool> fPluginShutdownRequested;
+
+    struct DeviceErrorState : std::runtime_error { using std::runtime_error::runtime_error; };
 }; /* class Control */
 
 auto ControlPluginProgramOptions() -> Plugin::ProgOptions;
 
 REGISTER_FAIRMQ_PLUGIN(
-    Control,                                     // Class name
-    control,                                     // Plugin name (string, lower case chars only)
-    (Plugin::Version{1,0,1}),                    // Version
-    "FairRootGroup <fairroot@gsi.de>",           // Maintainer
-    "https://github.com/FairRootGroup/FairRoot", // Homepage
-    ControlPluginProgramOptions                  // Free function which declares custom program options for the plugin
-                                                 // signature: () -> boost::optional<boost::program_options::options_description>
+    Control,   // Class name
+    control,   // Plugin name (string, lower case chars only)
+    (Plugin::Version{FAIRMQ_VERSION_MAJOR,
+                     FAIRMQ_VERSION_MINOR,
+                     FAIRMQ_VERSION_PATCH}),       // Version
+    "FairRootGroup <fairroot@gsi.de>",             // Maintainer
+    "https://github.com/FairRootGroup/FairRoot",   // Homepage
+    ControlPluginProgramOptions   // Free function which declares custom program options for the
+                                  // plugin signature: () ->
+                                  // boost::optional<boost::program_options::options_description>
 )
 
 } /* namespace plugins */

fairmq/plugins/DDS/DDS.cxx

@@ -31,7 +31,7 @@ namespace mq
 namespace plugins
 {
 
-DDS::DDS(const string name, const Plugin::Version version, const string maintainer, const string homepage, PluginServices* pluginServices)
+DDS::DDS(const string& name, const Plugin::Version version, const string& maintainer, const string& homepage, PluginServices* pluginServices)
     : Plugin(name, version, maintainer, homepage, pluginServices)
     , fService()
     , fDDSCustomCmd(fService)
@@ -48,26 +48,20 @@ DDS::DDS(const string name, const Plugin::Version version, const string maintain
     , fDeviceTerminationRequested(false)
     , fHeartbeatInterval{100}
 {
-    try
-    {
+    try {
         TakeDeviceControl();
         fControllerThread = thread(&DDS::HandleControl, this);
         fHeartbeatThread = thread(&DDS::HeartbeatSender, this);
-    }
-    catch (PluginServices::DeviceControlError& e)
-    {
+    } catch (PluginServices::DeviceControlError& e) {
         LOG(debug) << e.what();
-    }
-    catch (exception& e)
-    {
+    } catch (exception& e) {
         LOG(error) << "Error in plugin initialization: " << e.what();
     }
 }
 
 auto DDS::HandleControl() -> void
 {
-    try
-    {
+    try {
         // subscribe for state changes from DDS (subscriptions start firing after fService.start() is called)
         SubscribeForCustomCommands();
 
@@ -80,23 +74,20 @@ auto DDS::HandleControl() -> void
         SubscribeForConnectingChannels();
 
         // subscribe to device state changes, pushing new state chenges into the event queue
-        SubscribeToDeviceStateChange([&](DeviceState newState)
-        {
+        SubscribeToDeviceStateChange([&](DeviceState newState) {
             {
                 lock_guard<mutex> lock{fEventsMutex};
                 fEvents.push(newState);
             }
             fNewEvent.notify_one();
-            if (newState == DeviceState::Exiting)
-            {
+            if (newState == DeviceState::Exiting) {
                 fDeviceTerminationRequested = true;
             }
 
             {
                 lock_guard<mutex> lock{fStateChangeSubscriberMutex};
                 string id = GetProperty<string>("id");
-                for (auto subscriberId : fStateChangeSubscribers)
-                {
+                for (auto subscriberId : fStateChangeSubscribers) {
                     LOG(debug) << "Publishing state-change: " << newState << " to " << subscriberId;
                     fDDSCustomCmd.send("state-change: " + id + "," + ToStr(newState), to_string(subscriberId));
                 }
@@ -131,14 +122,11 @@ auto DDS::HandleControl() -> void
 
         // wait until stop signal
         unique_lock<mutex> lock(fStopMutex);
-        while (!fDeviceTerminationRequested)
-        {
+        while (!fDeviceTerminationRequested) {
             fStopCondition.wait_for(lock, chrono::seconds(1));
         }
         LOG(debug) << "Stopping DDS control plugin";
-    }
-    catch (exception& e)
-    {
+    } catch (exception& e) {
         LOG(error) << "Error: " << e.what() << endl;
         return;
     }
@@ -146,13 +134,10 @@ auto DDS::HandleControl() -> void
     fDDSKeyValue.unsubscribe();
     fDDSCustomCmd.unsubscribe();
 
-    try
-    {
+    try {
         UnsubscribeFromDeviceStateChange();
         ReleaseDeviceControl();
-    }
-    catch (fair::mq::PluginServices::DeviceControlError& e)
-    {
+    } catch (fair::mq::PluginServices::DeviceControlError& e) {
         LOG(error) << e.what();
     }
 }
@@ -194,7 +179,7 @@ auto DDS::FillChannelContainers() -> void
 
         for (const auto& vi : iValues) {
             size_t pos = vi.find(":");
-            string chanName = vi.substr(0, pos );
+            string chanName = vi.substr(0, pos);
 
             // check if provided name is a valid channel name
             if (fConnectingChans.find(chanName) == fConnectingChans.end()) {
@@ -229,11 +214,9 @@ auto DDS::FillChannelContainers() -> void
 
 auto DDS::SubscribeForConnectingChannels() -> void
 {
-    fDDSKeyValue.subscribe([&] (const string& propertyId, const string& key, const string& value)
-    {
-        try
-        {
-            LOG(debug) << "Received update for " << propertyId << ": key=" << key << " value=" << value;
+    fDDSKeyValue.subscribe([&] (const string& propertyId, const string& value, uint64_t senderTaskID) {
+        try {
+            LOG(debug) << "Received update for " << propertyId << ": value=" << value << ", senderTaskID=" << senderTaskID;
             string val = value;
             // check if it is to handle as one out of multiple values
             auto it = fIofN.find(propertyId);
@@ -254,20 +237,18 @@ auto DDS::SubscribeForConnectingChannels() -> void
                 auto it2 = fI.find(propertyId);
                 if (it2 != fI.end()) {
                     LOG(debug) << "adding connecting channel " << propertyId << " : " << connectionStrings.at(it2->second);
-                    fConnectingChans.at(propertyId).fDDSValues.insert(make_pair<string, string>(key.c_str(), connectionStrings.at(it2->second).c_str()));
+                    fConnectingChans.at(propertyId).fDDSValues.insert({senderTaskID, connectionStrings.at(it2->second).c_str()});
                 } else {
                     LOG(error) << "multiple bound channels received, but no task index specified, only assigning the first";
-                    fConnectingChans.at(propertyId).fDDSValues.insert(make_pair<string, string>(key.c_str(), connectionStrings.at(0).c_str()));
+                    fConnectingChans.at(propertyId).fDDSValues.insert({senderTaskID, connectionStrings.at(0).c_str()});
                 }
             } else { // only one bound channel received
-                fConnectingChans.at(propertyId).fDDSValues.insert(make_pair<string, string>(key.c_str(), val.c_str()));
+                fConnectingChans.at(propertyId).fDDSValues.insert({senderTaskID, val.c_str()});
             }
 
             // update channels and remove them from unfinished container
-            for (auto mi = fConnectingChans.begin(); mi != fConnectingChans.end(); /* no increment */)
-            {
-                if (mi->second.fSubChannelAddresses.size() == mi->second.fDDSValues.size())
-                {
+            for (auto mi = fConnectingChans.begin(); mi != fConnectingChans.end(); /* no increment */) {
+                if (mi->second.fSubChannelAddresses.size() == mi->second.fDDSValues.size()) {
                     // when multiple subChannels are used, their order on every device should be the same, irregardless of arrival order from DDS.
                     sort(mi->second.fSubChannelAddresses.begin(), mi->second.fSubChannelAddresses.end());
                     auto it3 = mi->second.fDDSValues.begin();
@@ -277,24 +258,19 @@ auto DDS::SubscribeForConnectingChannels() -> void
                         ++it3;
                     }
                     fConnectingChans.erase(mi++);
-                }
-                else
-                {
+                } else {
                     ++mi;
                 }
             }
-        }
-        catch (const exception& e)
-        {
-            LOG(error) << "Error on handling DDS property update for " << propertyId << ": key=" << key << " value=" << value << ": " << e.what();
+        } catch (const exception& e) {
+            LOG(error) << "Error on handling DDS property update for " << propertyId << ": value=" << value << ", senderTaskID=" << senderTaskID << ": " << e.what();
         }
     });
 }
 
 auto DDS::PublishBoundChannels() -> void
 {
-    for (const auto& chan : fBindingChans)
-    {
+    for (const auto& chan : fBindingChans) {
         string joined = boost::algorithm::join(chan.second, ",");
         LOG(debug) << "Publishing " << chan.first << " bound addresses (" << chan.second.size() << ") to DDS under '" << chan.first << "' property name.";
         fDDSKeyValue.putValue(chan.first, joined);
@@ -306,13 +282,11 @@ auto DDS::HeartbeatSender() -> void
     string id = GetProperty<string>("id");
     string pid(to_string(getpid()));
 
-    while (!fDeviceTerminationRequested)
-    {
+    while (!fDeviceTerminationRequested) {
         {
             lock_guard<mutex> lock{fHeartbeatSubscriberMutex};
 
-            for (const auto subscriberId : fHeartbeatSubscribers)
-            {
+            for (const auto subscriberId : fHeartbeatSubscribers) {
                 fDDSCustomCmd.send("heartbeat: " + id + "," + pid, to_string(subscriberId));
             }
         }
@@ -326,58 +300,42 @@ auto DDS::SubscribeForCustomCommands() -> void
     string id = GetProperty<string>("id");
     string pid(to_string(getpid()));
 
-    fDDSCustomCmd.subscribe([id, pid, this](const string& cmd, const string& cond, uint64_t senderId)
-    {
+    fDDSCustomCmd.subscribe([id, pid, this](const string& cmd, const string& cond, uint64_t senderId) {
         LOG(info) << "Received command: " << cmd;
 
-        if (cmd == "check-state")
-        {
+        if (cmd == "check-state") {
             fDDSCustomCmd.send(id + ": " + ToStr(GetCurrentDeviceState()) + " (pid: " + pid + ")", to_string(senderId));
-        }
-        else if (fCommands.find(cmd) != fCommands.end())
-        {
+        } else if (fCommands.find(cmd) != fCommands.end()) {
             fDDSCustomCmd.send(id + ": attempting to " + cmd, to_string(senderId));
             ChangeDeviceState(ToDeviceStateTransition(cmd));
-        }
-        else if (cmd == "END")
-        {
+        } else if (cmd == "END") {
             fDDSCustomCmd.send(id + ": attempting to " + cmd, to_string(senderId));
             ChangeDeviceState(ToDeviceStateTransition(cmd));
             fDDSCustomCmd.send(id + ": " + ToStr(GetCurrentDeviceState()), to_string(senderId));
-            if (ToStr(GetCurrentDeviceState()) == "EXITING")
-            {
+            if (ToStr(GetCurrentDeviceState()) == "EXITING") {
                 unique_lock<mutex> lock(fStopMutex);
                 fStopCondition.notify_one();
             }
-        }
-        else if (cmd == "dump-config")
-        {
+        } else if (cmd == "dump-config") {
             stringstream ss;
-            for (const auto pKey: GetPropertyKeys())
-            {
+            for (const auto pKey: GetPropertyKeys()) {
                 ss << id << ": " << pKey << " -> " << GetPropertyAsString(pKey) << endl;
             }
             fDDSCustomCmd.send(ss.str(), to_string(senderId));
-        }
-        else if (cmd == "subscribe-to-heartbeats")
-        {
+        } else if (cmd == "subscribe-to-heartbeats") {
             {
                 // auto size = fHeartbeatSubscribers.size();
                 lock_guard<mutex> lock{fHeartbeatSubscriberMutex};
                 fHeartbeatSubscribers.insert(senderId);
             }
             fDDSCustomCmd.send("heartbeat-subscription: " + id + ",OK", to_string(senderId));
-        }
-        else if (cmd == "unsubscribe-from-heartbeats")
-        {
+        } else if (cmd == "unsubscribe-from-heartbeats") {
             {
                 lock_guard<mutex> lock{fHeartbeatSubscriberMutex};
                 fHeartbeatSubscribers.erase(senderId);
             }
             fDDSCustomCmd.send("heartbeat-unsubscription: " + id + ",OK", to_string(senderId));
-        }
-        else if (cmd == "subscribe-to-state-changes")
-        {
+        } else if (cmd == "subscribe-to-state-changes") {
             {
                 // auto size = fStateChangeSubscribers.size();
                 lock_guard<mutex> lock{fStateChangeSubscriberMutex};
@@ -387,17 +345,13 @@ auto DDS::SubscribeForCustomCommands() -> void
             auto state = GetCurrentDeviceState();
             LOG(debug) << "Publishing state-change: " << state << " to " << senderId;
             fDDSCustomCmd.send("state-change: " + id + "," + ToStr(state), to_string(senderId));
-        }
-        else if (cmd == "unsubscribe-from-state-changes")
-        {
+        } else if (cmd == "unsubscribe-from-state-changes") {
             {
                 lock_guard<mutex> lock{fStateChangeSubscriberMutex};
                 fStateChangeSubscribers.erase(senderId);
             }
             fDDSCustomCmd.send("state-changes-unsubscription: " + id + ",OK", to_string(senderId));
-        }
-        else
-        {
+        } else {
             LOG(warn) << "Unknown command: " << cmd;
             LOG(warn) << "Origin: " << senderId;
             LOG(warn) << "Destination: " << cond;
@@ -408,8 +362,7 @@ auto DDS::SubscribeForCustomCommands() -> void
 auto DDS::WaitForNextState() -> DeviceState
 {
     unique_lock<mutex> lock{fEventsMutex};
-    while (fEvents.empty())
-    {
+    while (fEvents.empty()) {
         fNewEvent.wait(lock);
     }
 
@@ -420,13 +373,11 @@ auto DDS::WaitForNextState() -> DeviceState
 
 DDS::~DDS()
 {
-    if (fControllerThread.joinable())
-    {
+    if (fControllerThread.joinable()) {
         fControllerThread.join();
     }
 
-    if (fHeartbeatThread.joinable())
-    {
+    if (fHeartbeatThread.joinable()) {
         fHeartbeatThread.join();
     }
 }

fairmq/plugins/DDS/DDS.h

@@ -41,7 +41,7 @@ struct DDSConfig
     // container of sub channel addresses
     std::vector<std::string> fSubChannelAddresses;
     // dds values for the channel
-    std::unordered_map<std::string, std::string> fDDSValues;
+    std::unordered_map<uint64_t, std::string> fDDSValues;
 };
 
 struct IofN
@@ -61,7 +61,7 @@ struct IofN
 class DDS : public Plugin
 {
   public:
-    DDS(const std::string name, const Plugin::Version version, const std::string maintainer, const std::string homepage, PluginServices* pluginServices);
+    DDS(const std::string& name, const Plugin::Version version, const std::string& maintainer, const std::string& homepage, PluginServices* pluginServices);
 
     ~DDS();
 

fairmq/plugins/DDS/runDDSCommandUI.cxx

@@ -33,7 +33,7 @@ int main(int argc, char* argv[])
 {
     try {
         string sessionID;
-        char command;
+        char command = ' ';
         string topologyPath;
 
         bpo::options_description options("fairmq-dds-command-ui options");

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/runFairMQDevice.h

@@ -56,12 +56,12 @@ int main(int argc, char* argv[])
     }
     catch (std::exception& e)
     {
-        LOG(error) << "Unhandled exception reached the top of main: " << e.what() << ", application will now exit";
+        LOG(error) << "Uncaught exception reached the top of main: " << e.what();
         return 1;
     }
     catch (...)
     {
-        LOG(error) << "Non-exception instance being thrown. Please make sure you use std::runtime_exception() instead. Application will now exit.";
+        LOG(error) << "Uncaught exception reached the top of main.";
         return 1;
     }
 }

fairmq/shmem/Common.h

@@ -9,8 +9,13 @@
 #define FAIR_MQ_SHMEM_COMMON_H_
 
 #include <atomic>
+#include <string>
 
 #include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/functional/hash.hpp>
+
+#include <unistd.h>
+#include <sys/types.h>
 
 namespace fair
 {
@@ -73,6 +78,16 @@ struct RegionBlock
     size_t fHint;
 };
 
+// find id for unique shmem name:
+// a hash of user id + session id, truncated to 8 characters (to accommodate for name size limit on some systems (MacOS)).
+inline std::string buildShmIdFromSessionIdAndUserId(const std::string& sessionId)
+{
+    boost::hash<std::string> stringHash;
+    std::string shmId(std::to_string(stringHash(std::string((std::to_string(geteuid()) + sessionId)))));
+    shmId.resize(8, '_');
+    return shmId;
+}
+
 } // namespace shmem
 } // namespace mq
 } // namespace fair

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)
@@ -312,29 +316,6 @@ void FairMQMessageSHM::Copy(const FairMQMessage& msg)
     }
 }
 
-void FairMQMessageSHM::Copy(const FairMQMessagePtr& msg)
-{
-    if (fHandle < 0)
-    {
-        bipc::managed_shared_memory::handle_t otherHandle = static_cast<FairMQMessageSHM*>(msg.get())->fHandle;
-        if (otherHandle)
-        {
-            if (InitializeChunk(msg->GetSize()))
-            {
-                memcpy(GetData(), msg->GetData(), msg->GetSize());
-            }
-        }
-        else
-        {
-            LOG(error) << "copy fail: source message not initialized!";
-        }
-    }
-    else
-    {
-        LOG(error) << "copy fail: target message already initialized!";
-    }
-}
-
 void FairMQMessageSHM::CloseMessage()
 {
     if (fHandle >= 0 && !fQueued)
@@ -342,7 +323,7 @@ void FairMQMessageSHM::CloseMessage()
         if (fRegionId == 0)
         {
             fManager.Segment().deallocate(fManager.Segment().get_address_from_handle(fHandle));
-            fHandle = 0;
+            fHandle = -1;
         }
         else
         {
@@ -398,6 +379,7 @@ void FairMQMessageSHM::CloseMessage()
         {
             LOG(error) << "failed closing message, reason: " << zmq_strerror(errno);
         }
+        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;
@@ -47,7 +47,6 @@ class FairMQMessageSHM : public FairMQMessage
     fair::mq::Transport GetType() const override;
 
     void Copy(const FairMQMessage& msg) override;
-    void Copy(const FairMQMessagePtr& msg) override;
 
     ~FairMQMessageSHM() override;
 

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);
     }
@@ -68,10 +69,9 @@ FairMQPollerSHM::FairMQPollerSHM(const unordered_map<string, vector<FairMQChanne
     , fNumItems(0)
     , fOffsetMap()
 {
-    int offset = 0;
-
     try
     {
+        int offset = 0;
         // calculate offsets and the total size of the poll item set
         for (string channel : channelList)
         {
@@ -89,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);
             }
@@ -109,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)
@@ -189,7 +166,7 @@ bool FairMQPollerSHM::CheckOutput(const int index)
     return false;
 }
 
-bool FairMQPollerSHM::CheckInput(const string channelKey, const int index)
+bool FairMQPollerSHM::CheckInput(const string& channelKey, const int index)
 {
     try
     {
@@ -208,7 +185,7 @@ bool FairMQPollerSHM::CheckInput(const string channelKey, const int index)
     }
 }
 
-bool FairMQPollerSHM::CheckOutput(const string channelKey, const int index)
+bool FairMQPollerSHM::CheckOutput(const string& channelKey, const int index)
 {
     try
     {

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;
@@ -37,18 +37,16 @@ class FairMQPollerSHM : public FairMQPoller
     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;
+    bool CheckInput(const std::string& channelKey, const int index) override;
+    bool CheckOutput(const std::string& channelKey, const int index) override;
 
     ~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,11 +19,13 @@
 
 using namespace std;
 using namespace fair::mq::shmem;
+using namespace fair::mq;
 
 atomic<bool> FairMQSocketSHM::fInterrupted(false);
 
-FairMQSocketSHM::FairMQSocketSHM(Manager& manager, const string& type, const string& name, const string& id /*= ""*/, void* context)
-    : fSocket(nullptr)
+FairMQSocketSHM::FairMQSocketSHM(Manager& manager, const string& type, const string& name, const string& id /*= ""*/, void* context, FairMQTransportFactory* fac /*=nullptr*/)
+    : FairMQSocket{fac}
+    , fSocket(nullptr)
     , fManager(manager)
     , fId(id + "." + name + "." + type)
     , fBytesTx(0)
@@ -78,7 +81,7 @@ FairMQSocketSHM::FairMQSocketSHM(Manager& manager, const string& type, const str
         throw fair::mq::SocketError("PUB/SUB socket type is not supported for shared memory transport");
     }
 
-    // LOG(info) << "created socket " << fId;
+    LOG(debug) << "Created socket " << GetId();
 }
 
 bool FairMQSocketSHM::Bind(const string& address)
@@ -97,36 +100,31 @@ bool FairMQSocketSHM::Bind(const string& address)
     return true;
 }
 
-void FairMQSocketSHM::Connect(const string& address)
+bool FairMQSocketSHM::Connect(const string& address)
 {
     // LOG(info) << "connect socket " << fId << " on " << address;
 
     if (zmq_connect(fSocket, address.c_str()) != 0)
     {
         LOG(error) << "Failed connecting socket " << fId << ", reason: " << zmq_strerror(errno);
-        // error here means incorrect configuration. exit if it happens.
-        exit(EXIT_FAILURE);
+        return false;
     }
+
+    return true;
 }
 
-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 nbytes = -1;
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     while (true && !fInterrupted)
     {
-        nbytes = zmq_msg_send(static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(), fSocket, flags);
+        int nbytes = zmq_msg_send(static_cast<FairMQMessageSHM*>(msg.get())->GetMessage(), fSocket, flags);
         if (nbytes == 0)
         {
             return nbytes;
@@ -145,7 +143,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)
@@ -175,15 +173,19 @@ 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 nbytes = -1;
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     zmq_msg_t* msgPtr = static_cast<FairMQMessageSHM*>(msg.get())->GetMessage();
     while (true)
     {
-        nbytes = zmq_msg_recv(msgPtr, fSocket, flags);
+        int nbytes = zmq_msg_recv(msgPtr, fSocket, flags);
         if (nbytes == 0)
         {
             ++fMessagesRx;
@@ -218,7 +220,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)
@@ -246,14 +248,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();
-    int64_t totalSize = 0;
     int elapsed = 0;
 
     if (vecSize == 1) {
-        return SendImpl(msgVec.back(), flags, timeout);
+        return Send(msgVec.back(), timeout);
     }
 
     // put it into zmq message
@@ -263,7 +269,7 @@ int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
     // prepare the message with shm metas
     MetaHeader* metas = static_cast<MetaHeader*>(zmq_msg_data(&zmqMsg));
 
-    for (auto &msg : msgVec)
+    for (auto& msg : msgVec)
     {
         zmq_msg_t* metaMsg = static_cast<FairMQMessageSHM*>(msg.get())->GetMessage();
         memcpy(metas++, zmq_msg_data(metaMsg), sizeof(MetaHeader));
@@ -271,9 +277,8 @@ int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
 
     while (!fInterrupted)
     {
-        int nbytes = -1;
-        nbytes = zmq_msg_send(&zmqMsg, fSocket, flags);
-
+        int64_t totalSize = 0;
+        int nbytes = zmq_msg_send(&zmqMsg, fSocket, flags);
         if (nbytes == 0)
         {
             zmq_msg_close(&zmqMsg);
@@ -281,9 +286,9 @@ int64_t FairMQSocketSHM::SendImpl(vector<FairMQMessagePtr>& msgVec, const int fl
         }
         else if (nbytes > 0)
         {
-            assert(nbytes == (vecSize * sizeof(MetaHeader))); // all or nothing
+            assert(static_cast<unsigned int>(nbytes) == (vecSize * sizeof(MetaHeader))); // all or nothing
 
-            for (auto &msg : msgVec)
+            for (auto& msg : msgVec)
             {
                 FairMQMessageSHM* shmMsg = static_cast<FairMQMessageSHM*>(msg.get());
                 shmMsg->fQueued = true;
@@ -301,7 +306,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)
@@ -336,9 +341,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)
 {
-    int64_t totalSize = 0;
+    int flags = 0;
+    if (timeout == 0)
+    {
+        flags = ZMQ_DONTWAIT;
+    }
     int elapsed = 0;
 
     zmq_msg_t zmqMsg;
@@ -346,6 +355,7 @@ int64_t FairMQSocketSHM::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int
 
     while (!fInterrupted)
     {
+        int64_t totalSize = 0;
         int nbytes = zmq_msg_recv(&zmqMsg, fSocket, flags);
         if (nbytes == 0)
         {
@@ -368,7 +378,7 @@ int64_t FairMQSocketSHM::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int
                 MetaHeader metaHeader;
                 memcpy(&metaHeader, &hdrVec[m], sizeof(MetaHeader));
 
-                msgVec.emplace_back(fair::mq::tools::make_unique<FairMQMessageSHM>(fManager));
+                msgVec.emplace_back(fair::mq::tools::make_unique<FairMQMessageSHM>(fManager, GetTransport()));
 
                 FairMQMessageSHM* msg = static_cast<FairMQMessageSHM*>(msgVec.back().get());
                 MetaHeader* msgHdr = static_cast<MetaHeader*>(zmq_msg_data(msg->GetMessage()));
@@ -394,7 +404,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)
@@ -459,12 +469,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)
@@ -481,6 +485,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;
@@ -501,112 +590,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

@@ -15,31 +15,26 @@
 
 #include <atomic>
 #include <memory> // unique_ptr
+class FairMQTransportFactory;
 
-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);
+    FairMQSocketSHM(fair::mq::shmem::Manager& manager, const std::string& type, const std::string& name, const std::string& id = "", void* context = nullptr, FairMQTransportFactory* fac = nullptr);
     FairMQSocketSHM(const FairMQSocketSHM&) = delete;
     FairMQSocketSHM operator=(const FairMQSocketSHM&) = delete;
 
     std::string GetId() override { return fId; }
 
     bool Bind(const std::string& address) override;
-    void Connect(const std::string& address) override;
+    bool 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 +44,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 +77,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

@@ -37,7 +37,7 @@ fair::mq::Transport FairMQTransportFactorySHM::fTransportType = fair::mq::Transp
 FairMQTransportFactorySHM::FairMQTransportFactorySHM(const string& id, const FairMQProgOptions* config)
     : FairMQTransportFactory(id)
     , fDeviceId(id)
-    , fSessionName("default")
+    , fShmId()
     , fContext(nullptr)
     , fHeartbeatThread()
     , fSendHeartbeats(true)
@@ -58,12 +58,13 @@ FairMQTransportFactorySHM::FairMQTransportFactorySHM(const string& id, const Fai
     }
 
     int numIoThreads = 1;
+    string sessionName = "default";
     size_t segmentSize = 2000000000;
     bool autolaunchMonitor = false;
     if (config)
     {
         numIoThreads = config->GetValue<int>("io-threads");
-        fSessionName = config->GetValue<string>("session");
+        sessionName = config->GetValue<string>("session");
         segmentSize = config->GetValue<size_t>("shm-segment-size");
         autolaunchMonitor = config->GetValue<bool>("shm-monitor");
     }
@@ -72,11 +73,11 @@ FairMQTransportFactorySHM::FairMQTransportFactorySHM(const string& id, const Fai
         LOG(debug) << "FairMQProgOptions not available! Using defaults.";
     }
 
-    fSessionName.resize(8, '_'); // shorten the session name, to accommodate for name size limit on some systems (MacOS)
+    fShmId = buildShmIdFromSessionIdAndUserId(sessionName);
 
     try
     {
-        fShMutex = fair::mq::tools::make_unique<bipc::named_mutex>(bipc::open_or_create, string("fmq_" + fSessionName + "_mtx").c_str());
+        fShMutex = fair::mq::tools::make_unique<bipc::named_mutex>(bipc::open_or_create, string("fmq_" + fShmId + "_mtx").c_str());
 
         if (zmq_ctx_set(fContext, ZMQ_IO_THREADS, numIoThreads) != 0)
         {
@@ -89,8 +90,8 @@ FairMQTransportFactorySHM::FairMQTransportFactorySHM(const string& id, const Fai
             LOG(error) << "failed configuring context, reason: " << zmq_strerror(errno);
         }
 
-        fManager = fair::mq::tools::make_unique<Manager>(fSessionName, segmentSize);
-        LOG(debug) << "created/opened shared memory segment '" << "fmq_" << fSessionName << "_main" << "' of " << segmentSize << " bytes. Available are " << fManager->Segment().get_free_memory() << " bytes.";
+        fManager = fair::mq::tools::make_unique<Manager>(fShmId, segmentSize);
+        LOG(debug) << "created/opened shared memory segment '" << "fmq_" << fShmId << "_main" << "' of " << segmentSize << " bytes. Available are " << fManager->Segment().get_free_memory() << " bytes.";
 
         {
             bipc::scoped_lock<bipc::named_mutex> lock(*fShMutex);
@@ -145,8 +146,6 @@ FairMQTransportFactorySHM::FairMQTransportFactorySHM(const string& id, const Fai
 
 void FairMQTransportFactorySHM::StartMonitor()
 {
-    int numTries = 0;
-
     auto env = boost::this_process::environment();
 
     vector<bfs::path> ownPath = boost::this_process::path();
@@ -160,8 +159,8 @@ void FairMQTransportFactorySHM::StartMonitor()
 
     if (!p.empty())
     {
-        boost::process::spawn(p, "-x", "-s", fSessionName, "-d", "-t", "2000", env);
-
+        boost::process::spawn(p, "-x", "--shmid", fShmId, "-d", "-t", "2000", env);
+        int numTries = 0;
         do
         {
             MonitorStatus* monitorStatus = fManager->ManagementSegment().find<MonitorStatus>(bipc::unique_instance).first;
@@ -190,7 +189,7 @@ void FairMQTransportFactorySHM::StartMonitor()
 
 void FairMQTransportFactorySHM::SendHeartbeats()
 {
-    string controlQueueName("fmq_" + fSessionName + "_cq");
+    string controlQueueName("fmq_" + fShmId + "_cq");
     while (fSendHeartbeats)
     {
         try
@@ -214,30 +213,30 @@ 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
+FairMQSocketPtr FairMQTransportFactorySHM::CreateSocket(const string& type, const string& name)
 {
     assert(fContext);
-    return unique_ptr<FairMQSocket>(new FairMQSocketSHM(*fManager, type, name, GetId(), fContext));
+    return unique_ptr<FairMQSocket>(new FairMQSocketSHM(*fManager, type, name, GetId(), fContext, this));
 }
 
 FairMQPollerPtr FairMQTransportFactorySHM::CreatePoller(const vector<FairMQChannel>& channels) const
@@ -245,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));
 }
@@ -255,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));
@@ -312,7 +306,7 @@ FairMQTransportFactorySHM::~FairMQTransportFactorySHM()
 
     if (lastRemoved)
     {
-        boost::interprocess::named_mutex::remove(string("fmq_" + fSessionName + "_mtx").c_str());
+        bipc::named_mutex::remove(string("fmq_" + fShmId + "_mtx").c_str());
     }
 }
 

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;
+    FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) 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;
 
@@ -60,7 +60,7 @@ class FairMQTransportFactorySHM : public FairMQTransportFactory
 
     static fair::mq::Transport fTransportType;
     std::string fDeviceId;
-    std::string fSessionName;
+    std::string fShmId;
     void* fContext;
     std::thread fHeartbeatThread;
     std::atomic<bool> fSendHeartbeats;

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/Manager.cxx

@@ -105,7 +105,7 @@ void Manager::RemoveSegment()
 {
     if (bipc::shared_memory_object::remove(fSegmentName.c_str()))
     {
-        LOG(debug) << "successfully removed " << fSegmentName << " segment after the device has stopped.";
+        LOG(debug) << "successfully removed '" << fSegmentName << "' segment after the device has stopped.";
     }
     else
     {

fairmq/shmem/Monitor.cxx

@@ -51,17 +51,17 @@ void signalHandler(int signal)
     gSignalStatus = signal;
 }
 
-Monitor::Monitor(const string& sessionName, bool selfDestruct, bool interactive, unsigned int timeoutInMS, bool runAsDaemon, bool cleanOnExit)
+Monitor::Monitor(const string& shmId, bool selfDestruct, bool interactive, unsigned int timeoutInMS, bool runAsDaemon, bool cleanOnExit)
     : fSelfDestruct(selfDestruct)
     , fInteractive(interactive)
     , fSeenOnce(false)
     , fIsDaemon(runAsDaemon)
     , fCleanOnExit(cleanOnExit)
     , fTimeoutInMS(timeoutInMS)
-    , fSessionName(sessionName)
-    , fSegmentName("fmq_" + fSessionName + "_main")
-    , fManagementSegmentName("fmq_" + fSessionName + "_mng")
-    , fControlQueueName("fmq_" + fSessionName + "_cq")
+    , fShmId(shmId)
+    , fSegmentName("fmq_" + fShmId + "_main")
+    , fManagementSegmentName("fmq_" + fShmId + "_mng")
+    , fControlQueueName("fmq_" + fShmId + "_cq")
     , fTerminating(false)
     , fHeartbeatTriggered(false)
     , fLastHeartbeat(chrono::high_resolution_clock::now())
@@ -201,7 +201,7 @@ void Monitor::Interactive()
                     break;
                 case 'x':
                     cout << "\n[x] --> closing shared memory:" << endl;
-                    Cleanup(fSessionName);
+                    Cleanup(fShmId);
                     break;
                 case 'h':
                     cout << "\n[h] --> help:" << endl << endl;
@@ -245,11 +245,11 @@ void Monitor::Interactive()
 
 void Monitor::CheckSegment()
 {
-    static uint64_t counter = 0;
     char c = '#';
 
     if (fInteractive)
     {
+        static uint64_t counter = 0;
         int mod = counter++ % 5;
         switch (mod)
         {
@@ -293,7 +293,7 @@ void Monitor::CheckSegment()
         if (fHeartbeatTriggered && duration > fTimeoutInMS)
         {
             cout << "no heartbeats since over " << fTimeoutInMS << " milliseconds, cleaning..." << endl;
-            Cleanup(fSessionName);
+            Cleanup(fShmId);
             fHeartbeatTriggered = false;
             if (fSelfDestruct)
             {
@@ -340,7 +340,7 @@ void Monitor::CheckSegment()
 
         if (fIsDaemon && duration > fTimeoutInMS * 2)
         {
-            Cleanup(fSessionName);
+            Cleanup(fShmId);
             fHeartbeatTriggered = false;
             if (fSelfDestruct)
             {
@@ -360,9 +360,9 @@ void Monitor::CheckSegment()
     }
 }
 
-void Monitor::Cleanup(const string& sessionName)
+void Monitor::Cleanup(const string& shmId)
 {
-    string managementSegmentName("fmq_" + sessionName + "_mng");
+    string managementSegmentName("fmq_" + shmId + "_mng");
     try
     {
         bipc::managed_shared_memory managementSegment(bipc::open_only, managementSegmentName.c_str());
@@ -373,8 +373,8 @@ void Monitor::Cleanup(const string& sessionName)
             unsigned int regionCount = rc->fCount;
             for (unsigned int i = 1; i <= regionCount; ++i)
             {
-                RemoveObject("fmq_" + sessionName + "_rg_" + to_string(i));
-                RemoveQueue(string("fmq_" + sessionName + "_rgq_" + to_string(i)));
+                RemoveObject("fmq_" + shmId + "_rg_" + to_string(i));
+                RemoveQueue(string("fmq_" + shmId + "_rgq_" + to_string(i)));
             }
         }
         else
@@ -389,9 +389,8 @@ void Monitor::Cleanup(const string& sessionName)
         cout << "Did not find '" << managementSegmentName << "' shared memory segment. No regions to cleanup." << endl;
     }
 
-    RemoveObject("fmq_" + sessionName + "_main");
-
-    boost::interprocess::named_mutex::remove(string("fmq_" + sessionName + "_mtx").c_str());
+    RemoveObject("fmq_" + shmId + "_main");
+    RemoveMutex("fmq_" + shmId + "_mtx");
 
     cout << endl;
 }
@@ -420,6 +419,18 @@ void Monitor::RemoveQueue(const string& name)
     }
 }
 
+void Monitor::RemoveMutex(const string& name)
+{
+    if (bipc::named_mutex::remove(name.c_str()))
+    {
+        cout << "Successfully removed \"" << name << "\"." << endl;
+    }
+    else
+    {
+        cout << "Did not remove \"" << name << "\". Already removed?" << endl;
+    }
+}
+
 void Monitor::PrintQueues()
 {
     cout << '\n';
@@ -427,14 +438,14 @@ void Monitor::PrintQueues()
     try
     {
         bipc::managed_shared_memory segment(bipc::open_only, fSegmentName.c_str());
-        StringVector* queues = segment.find<StringVector>(string("fmq_" + fSessionName + "_qs").c_str()).first;
+        StringVector* queues = segment.find<StringVector>(string("fmq_" + fShmId + "_qs").c_str()).first;
         if (queues)
         {
             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)
@@ -500,7 +511,7 @@ Monitor::~Monitor()
     }
     if (fCleanOnExit)
     {
-        Cleanup(fSessionName);
+        Cleanup(fShmId);
     }
 }
 

fairmq/shmem/Monitor.h

@@ -39,6 +39,7 @@ class Monitor
     static void Cleanup(const std::string& sessionName);
     static void RemoveObject(const std::string&);
     static void RemoveQueue(const std::string&);
+    static void RemoveMutex(const std::string&);
 
   private:
     void PrintHeader();
@@ -55,7 +56,7 @@ class Monitor
     bool fIsDaemon;
     bool fCleanOnExit;
     unsigned int fTimeoutInMS;
-    std::string fSessionName;
+    std::string fShmId;
     std::string fSegmentName;
     std::string fManagementSegmentName;
     std::string fControlQueueName;
@@ -71,4 +72,4 @@ class Monitor
 } // namespace mq
 } // namespace fair
 
-#endif /* FAIR_MQ_SHMEM_MONITOR_H_ */
+#endif /* FAIR_MQ_SHMEM_MONITOR_H_ */

fairmq/shmem/README.md

@@ -12,8 +12,9 @@ The shared memory monitor tool, supplied with the shared memory transport can be
 
 With default arguments the monitor will run indefinitely with no output, and clean up shared memory segment if it is open and no heartbeats from devices arrive within a timeout period. It can be further customized with following parameters:
 
-  `--session <arg>`: customize the name of the shared memory segment via the session name (default is "default").
+  `--session <arg>`: for which session to run the monitor (default is "default"). The actual ressource names will be built out of session id, user id (hashed and truncated).
   `--cleanup`: start monitor, perform cleanup of the memory and quit.
+  `--shmid <arg>`: if provided, this shmem id will be used instead of the one generated from session id. Use this if you know the name of the shared memory ressource, but do not have the used session id.
   `--self-destruct`: run until the memory segment is closed (either naturally via cleanup performed by devices or in case of a crash (no heartbeats within timeout)).
   `--interactive`: run interactively, with detailed segment details and user input for various shmem operations.
   `--timeout <arg>`: specifiy the timeout for the heartbeats from shmem transports in milliseconds (default 5000).
@@ -27,9 +28,9 @@ The Monitor class can also be used independently from the supplied executable (b
 
 FairMQ Shared Memory currently uses following names to register shared memory on the system:
 
-`fmq_<sessionName>_main` - main segment name, used for user data (session name can be overridden via `--session`).
-`fmq_<sessionName>_mng` - management segment name, used for storing management data.
-`fmq_<sessionName>_cq` - message queue for communicating between shm transport and shm monitor (exists independent of above segments).
-`fmq_<sessionName>_mtx` - boost::interprocess::named_mutex for management purposes (exists independent of above segments).
-`fmq_<sessionName>_rg_<index>` - names of unmanaged regions.
-`fmq_<sessionName>_rgq_<index>` - names of queues for the unmanaged regions.
+`fmq_<shmId>_main` - main segment name, used for user data (the shmId is generated out of session id and user id).
+`fmq_<shmId>_mng` - management segment name, used for storing management data.
+`fmq_<shmId>_cq` - message queue for communicating between shm transport and shm monitor (exists independent of above segments).
+`fmq_<shmId>_mtx` - boost::interprocess::named_mutex for management purposes (exists independent of above segments).
+`fmq_<shmId>_rg_<index>` - names of unmanaged regions.
+`fmq_<shmId>_rgq_<index>` - names of queues for the unmanaged regions.

fairmq/shmem/prototype/CMakeLists.txt

@@ -1,76 +0,0 @@
- ################################################################################
- #    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"                       #
- ################################################################################
-
-configure_file(${CMAKE_SOURCE_DIR}/fairmq/shmem/prototype/shm-prototype.json
-               ${CMAKE_BINARY_DIR}/bin/config/shm-prototype.json)
-configure_file(${CMAKE_SOURCE_DIR}/fairmq/shmem/prototype/startShmPrototype.sh.in
-               ${CMAKE_BINARY_DIR}/bin/prototype/shmem/startShmPrototype.sh)
-
-Set(INCLUDE_DIRECTORIES
-  ${CMAKE_SOURCE_DIR}/fairmq
-  ${CMAKE_SOURCE_DIR}/fairmq/zeromq
-  ${CMAKE_SOURCE_DIR}/fairmq/nanomsg
-  ${CMAKE_SOURCE_DIR}/fairmq/devices
-  ${CMAKE_SOURCE_DIR}/fairmq/tools
-  ${CMAKE_SOURCE_DIR}/fairmq/options
-  ${CMAKE_SOURCE_DIR}/fairmq/shmem/prototype
-  ${CMAKE_CURRENT_BINARY_DIR}
-)
-
-Set(SYSTEM_INCLUDE_DIRECTORIES
-  ${Boost_INCLUDE_DIR}
-  ${ZeroMQ_INCLUDE_DIR}
-)
-
-Include_Directories(${INCLUDE_DIRECTORIES})
-Include_Directories(SYSTEM ${SYSTEM_INCLUDE_DIRECTORIES})
-
-Set(LINK_DIRECTORIES
-  ${Boost_LIBRARY_DIRS}
-)
-
-Link_Directories(${LINK_DIRECTORIES})
-
-Set(SRCS
-  "FairMQShmPrototypeSampler.cxx"
-  "FairMQShmPrototypeSink.cxx"
-)
-
-Set(DEPENDENCIES
-  ${DEPENDENCIES}
-  ${Boost_INTERPROCESS_LIBRARY}
-  FairMQ
-)
-
-Set(LIBRARY_NAME FairMQShmPrototype)
-
-GENERATE_LIBRARY()
-
-Set(Exe_Names
-  shm-prototype-sampler
-  shm-prototype-sink
-)
-
-Set(Exe_Source
-  runShmPrototypeSampler.cxx
-  runShmPrototypeSink.cxx
-)
-
-list(LENGTH Exe_Names _length)
-math(EXPR _length ${_length}-1)
-
-set(EXECUTABLE_OUTPUT_PATH "${EXECUTABLE_OUTPUT_PATH}/prototype/shmem")
-
-ForEach(_file RANGE 0 ${_length})
-  list(GET Exe_Names ${_file} _name)
-  list(GET Exe_Source ${_file} _src)
-  set(EXE_NAME ${_name})
-  set(SRCS ${_src})
-  set(DEPENDENCIES FairMQShmPrototype)
-  GENERATE_EXECUTABLE()
-EndForEach(_file RANGE 0 ${_length})

fairmq/shmem/prototype/FairMQShmPrototypeSampler.cxx

@@ -1,227 +0,0 @@
-/********************************************************************************
- *    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"                       *
- ********************************************************************************/
-/**
- * FairMQShmPrototypeSampler.cpp
- *
- * @since 2016-04-08
- * @author A. Rybalchenko
- */
-
-#include <string>
-#include <thread>
-#include <chrono>
-#include <iomanip>
-
-#include <boost/interprocess/managed_shared_memory.hpp>
-#include <boost/interprocess/smart_ptr/shared_ptr.hpp>
-
-#include "FairMQShmPrototypeSampler.h"
-#include "FairMQProgOptions.h"
-#include "FairMQLogger.h"
-
-#include "ShmChunk.h"
-
-using namespace std;
-using namespace boost::interprocess;
-
-FairMQShmPrototypeSampler::FairMQShmPrototypeSampler()
-    : fMsgSize(10000)
-    , fMsgCounter(0)
-    , fMsgRate(1)
-    , fBytesOut(0)
-    , fMsgOut(0)
-    , fBytesOutNew(0)
-    , fMsgOutNew(0)
-{
-    if (shared_memory_object::remove("FairMQSharedMemoryPrototype"))
-    {
-        LOG(info) << "Successfully removed shared memory upon device start.";
-    }
-    else
-    {
-        LOG(info) << "Did not remove shared memory upon device start.";
-    }
-}
-
-FairMQShmPrototypeSampler::~FairMQShmPrototypeSampler()
-{
-    if (shared_memory_object::remove("FairMQSharedMemoryPrototype"))
-    {
-        LOG(info) << "Successfully removed shared memory after the device has stopped.";
-    }
-    else
-    {
-        LOG(info) << "Did not remove shared memory after the device stopped. Still in use?";
-    }
-}
-
-void FairMQShmPrototypeSampler::Init()
-{
-    fMsgSize = fConfig->GetValue<int>("msg-size");
-    fMsgRate = fConfig->GetValue<int>("msg-rate");
-
-    SegmentManager::Instance().InitializeSegment("open_or_create", "FairMQSharedMemoryPrototype", 2000000000);
-    LOG(info) << "Created/Opened shared memory segment of 2,000,000,000 bytes. Available are "
-              << SegmentManager::Instance().Segment()->get_free_memory() << " bytes.";
-}
-
-void FairMQShmPrototypeSampler::Run()
-{
-    // count sent messages (also used in creating ShmChunk container ID)
-    static uint64_t numSentMsgs = 0;
-
-    LOG(info) << "Starting the benchmark with message size of " << fMsgSize;
-
-    // start rate logger and acknowledgement listener in separate threads
-    thread rateLogger(&FairMQShmPrototypeSampler::Log, this, 1000);
-    // thread resetMsgCounter(&FairMQShmPrototypeSampler::ResetMsgCounter, this);
-
-    // int charnum = 97;
-
-    while (CheckCurrentState(RUNNING))
-    {
-        void* ptr = nullptr;
-        bipc::managed_shared_memory::handle_t handle;
-
-        while (!ptr)
-        {
-            try
-            {
-                ptr = SegmentManager::Instance().Segment()->allocate(fMsgSize);
-            }
-            catch (bipc::bad_alloc& ba)
-            {
-                this_thread::sleep_for(chrono::milliseconds(50));
-                if (CheckCurrentState(RUNNING))
-                {
-                    continue;
-                }
-                else
-                {
-                    break;
-                }
-            }
-        }
-
-        // // ShmChunk container ID
-        // string chunkID = "c" + to_string(numSentMsgs);
-        // // shared pointer ID
-        // string ownerID = "o" + to_string(numSentMsgs);
-
-        // ShPtrOwner* owner = nullptr;
-
-        // try
-        // {
-        //     owner = SegmentManager::Instance().Segment()->construct<ShPtrOwner>(ownerID.c_str())(
-        //         make_managed_shared_ptr(SegmentManager::Instance().Segment()->construct<ShmChunk>(chunkID.c_str())(fMsgSize),
-        //                                 *(SegmentManager::Instance().Segment())));
-        // }
-        // catch (bipc::bad_alloc& ba)
-        // {
-        //     LOG(warn) << "Shared memory full...";
-        //     this_thread::sleep_for(chrono::milliseconds(100));
-        //     continue;
-        // }
-
-        // void* ptr = owner->fPtr->GetData();
-
-        // write something to memory, otherwise only (incomplete) allocation will be measured
-        // memset(ptr, 0, fMsgSize);
-
-        // static_cast<char*>(ptr)[3] = charnum++;
-        // if (charnum == 123)
-        // {
-        //     charnum = 97;
-        // }
-
-        // LOG(debug) << "chunk handle: " << owner->fPtr->GetHandle();
-        // LOG(debug) << "chunk size: " << owner->fPtr->GetSize();
-        // LOG(debug) << "owner (" << ownerID << ") use count: " << owner->fPtr.use_count();
-
-        // char* cptr = static_cast<char*>(ptr);
-        // LOG(debug) << "check: " << cptr[3];
-
-        // FairMQMessagePtr msg(NewSimpleMessage(ownerID));
-
-        if (ptr)
-        {
-            handle = SegmentManager::Instance().Segment()->get_handle_from_address(ptr);
-            FairMQMessagePtr msg(NewMessage(sizeof(ExMetaHeader)));
-            ExMetaHeader* metaPtr = new(msg->GetData()) ExMetaHeader();
-            metaPtr->fSize = fMsgSize;
-            metaPtr->fHandle = handle;
-
-            // LOG(info) << metaPtr->fSize;
-            // LOG(info) << metaPtr->fHandle;
-            // LOG(warn) << ptr;
-
-            if (Send(msg, "meta", 0) > 0)
-            {
-                fBytesOutNew += fMsgSize;
-                ++fMsgOutNew;
-                ++numSentMsgs;
-            }
-            else
-            {
-                SegmentManager::Instance().Segment()->deallocate(ptr);
-                // SegmentManager::Instance().Segment()->destroy_ptr(owner);
-            }
-        }
-
-        // --fMsgCounter;
-        // while (fMsgCounter == 0)
-        // {
-        //     this_thread::sleep_for(chrono::milliseconds(1));
-        // }
-    }
-
-    LOG(info) << "Sent " << numSentMsgs << " messages, leaving RUNNING state.";
-
-    rateLogger.join();
-    // resetMsgCounter.join();
-}
-
-void FairMQShmPrototypeSampler::Log(const int intervalInMs)
-{
-    chrono::time_point<chrono::high_resolution_clock> t0 = chrono::high_resolution_clock::now();
-    chrono::time_point<chrono::high_resolution_clock> t1;
-    unsigned long long msSinceLastLog;
-
-    double mbPerSecOut = 0;
-    double msgPerSecOut = 0;
-
-    while (CheckCurrentState(RUNNING))
-    {
-        t1 = chrono::high_resolution_clock::now();
-
-        msSinceLastLog = chrono::duration_cast<chrono::milliseconds>(t1 - t0).count();
-
-        mbPerSecOut = (static_cast<double>(fBytesOutNew - fBytesOut) / (1024. * 1024.)) / static_cast<double>(msSinceLastLog) * 1000.;
-        fBytesOut = fBytesOutNew;
-
-        msgPerSecOut = static_cast<double>(fMsgOutNew - fMsgOut) / static_cast<double>(msSinceLastLog) * 1000.;
-        fMsgOut = fMsgOutNew;
-
-        LOG(debug) << fixed
-                   << setprecision(0) << "out: " << msgPerSecOut << " msg ("
-                   << setprecision(2) << mbPerSecOut << " MB)\t("
-                   << SegmentManager::Instance().Segment()->get_free_memory() / (1024. * 1024.) << " MB free)";
-
-        t0 = t1;
-        this_thread::sleep_for(chrono::milliseconds(intervalInMs));
-    }
-}
-
-void FairMQShmPrototypeSampler::ResetMsgCounter()
-{
-    while (CheckCurrentState(RUNNING))
-    {
-        fMsgCounter = fMsgRate / 100;
-        this_thread::sleep_for(chrono::milliseconds(10));
-    }
-}