shmmonitor: update docs

Use value initialization to prevent

error: temporary of type ... has protected destructor

see https://stackoverflow.com/a/56745475

.clang-tidy

@@ -1,3 +1,3 @@
 ---
-Checks:          '*,-google-*,-fuchsia-*,-cert-*,-llvm-header-guard,-readability-named-parameter,-misc-non-private-member-variables-in-classes,-*-magic-numbers,-llvm-include-order,-hicpp-no-array-decay,-performance-unnecessary-value-param,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-modernize-use-trailing-return-type,-readability-redundant-member-init'
+Checks:            'cppcoreguidelines-*,misc-unused-alias-decls,misc-unused-parameters,modernize-deprecated-headers,modernize-raw-string-literal,modernize-redundant-void-arg,modernize-use-bool-literals,modernize-use-default-member-init,modernize-use-emplace,modernize-use-equals-default,modernize-use-equals-delete,modernize-use-noexcept,modernize-use-nullptr,modernize-use-override,modernize-use-using,performance-faster-string-find,performance-for-range-copy,performance-unnecessary-copy-initialization,readability-avoid-const-params-in-decls,readability-braces-around-statements,readability-container-size-empty,readability-delete-null-pointer,readability-redundant-member-init,readability-redundant-string-init,readability-static-accessed-through-instance,readability-string-compare'
 HeaderFilterRegex: '/(fairmq/)'

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "extern/asio"]
 	path = extern/asio
 	url = https://github.com/chriskohlhoff/asio
+[submodule "extern/PicoSHA2"]
+	path = extern/PicoSHA2
+	url = https://github.com/okdshin/PicoSHA2

CMakeLists.txt

@@ -18,11 +18,7 @@ get_git_version()
 project(FairMQ VERSION ${PROJECT_VERSION} LANGUAGES CXX)
 message(STATUS "${BWhite}${PROJECT_NAME}${CR} ${PROJECT_GIT_VERSION} from ${PROJECT_DATE}")
 
-if(BUILD_OFI_TRANSPORT OR BUILD_SDK OR BUILD_PMIX_PLUGIN)
+set(PROJECT_MIN_CXX_STANDARD 17)
-  set(PROJECT_MIN_CXX_STANDARD 14)
-else()
-  set(PROJECT_MIN_CXX_STANDARD 11)
-endif()
 
 set_fairmq_defaults()
 
@@ -31,28 +27,30 @@ include(CTest)
 
 
 # Build options ################################################################
-fairmq_build_option(BUILD_FAIRMQ            "Build FairMQ library and devices."
+fairmq_build_option(BUILD_FAIRMQ        "Build FairMQ library and devices."
-                                             DEFAULT ON)
+                                         DEFAULT ON)
-fairmq_build_option(BUILD_TESTING           "Build tests."
+fairmq_build_option(BUILD_TESTING       "Build tests."
-                                             DEFAULT OFF REQUIRES "BUILD_FAIRMQ")
+                                         DEFAULT OFF REQUIRES "BUILD_FAIRMQ")
-fairmq_build_option(BUILD_OFI_TRANSPORT     "Build experimental OFI transport."
+fairmq_build_option(BUILD_OFI_TRANSPORT "Build experimental OFI transport."
-                                             DEFAULT OFF REQUIRES "BUILD_FAIRMQ")
+                                         DEFAULT OFF REQUIRES "BUILD_FAIRMQ")
-fairmq_build_option(BUILD_SDK_COMMANDS      "Build the FairMQ SDK commands."
+fairmq_build_option(BUILD_SDK_COMMANDS  "Build the FairMQ SDK commands."
-                                             DEFAULT OFF)
+                                         DEFAULT OFF)
-fairmq_build_option(BUILD_DDS_PLUGIN        "Build DDS plugin."
+fairmq_build_option(BUILD_DDS_PLUGIN    "Build DDS plugin."
-                                             DEFAULT OFF REQUIRES "BUILD_FAIRMQ;BUILD_SDK_COMMANDS")
+                                         DEFAULT OFF REQUIRES "BUILD_FAIRMQ;BUILD_SDK_COMMANDS")
-fairmq_build_option(BUILD_PMIX_PLUGIN       "Build PMIx plugin."
+fairmq_build_option(BUILD_PMIX_PLUGIN   "Build PMIx plugin."
-                                             DEFAULT OFF REQUIRES "BUILD_FAIRMQ;BUILD_SDK_COMMANDS")
+                                         DEFAULT OFF REQUIRES "BUILD_FAIRMQ;BUILD_SDK_COMMANDS")
-fairmq_build_option(BUILD_EXAMPLES          "Build FairMQ examples."
+fairmq_build_option(BUILD_EXAMPLES      "Build FairMQ examples."
-                                             DEFAULT ON  REQUIRES "BUILD_FAIRMQ")
+                                         DEFAULT ON  REQUIRES "BUILD_FAIRMQ")
-fairmq_build_option(BUILD_SDK               "Build the FairMQ controller SDK."
+fairmq_build_option(BUILD_SDK           "Build the FairMQ controller SDK."
-                                             DEFAULT OFF REQUIRES "BUILD_DDS_PLUGIN;BUILD_SDK_COMMANDS")
+                                         DEFAULT OFF REQUIRES "BUILD_DDS_PLUGIN;BUILD_SDK_COMMANDS")
-fairmq_build_option(BUILD_DOCS              "Build FairMQ documentation."
+fairmq_build_option(BUILD_DOCS          "Build FairMQ documentation."
-                                             DEFAULT OFF)
+                                         DEFAULT OFF)
-fairmq_build_option(FAST_BUILD              "Fast production build. Not recommended for development."
+fairmq_build_option(FAST_BUILD          "Fast production build. Not recommended for development."
-                                             DEFAULT OFF)
+                                         DEFAULT OFF)
-fairmq_build_option(USE_EXTERNAL_GTEST      "Do not use bundled GTest. Not recommended."
+fairmq_build_option(USE_EXTERNAL_GTEST  "Do not use bundled GTest. Not recommended."
-                                             DEFAULT OFF)
+                                         DEFAULT OFF)
+fairmq_build_option(FAIRMQ_DEBUG_MODE   "Compile in debug mode (may decrease performance)."
+                                         DEFAULT OFF)
 ################################################################################
 
 
@@ -80,7 +78,7 @@ endif()
 
 if(BUILD_DDS_PLUGIN OR BUILD_SDK)
   find_package2(PRIVATE DDS REQUIRED
-    VERSION 3.0
+    VERSION 3.5.3
   )
   set(DDS_Boost_COMPONENTS system log log_setup regex filesystem thread)
   set(DDS_Boost_VERSION 1.67)
@@ -94,7 +92,7 @@ endif()
 
 if(BUILD_FAIRMQ OR BUILD_SDK)
   find_package2(PUBLIC FairLogger REQUIRED
-    VERSION 1.2.0
+    VERSION 1.6.0
   )
 
   foreach(dep IN LISTS FairLogger_PACKAGE_DEPENDENCIES)
@@ -134,7 +132,7 @@ endif()
 
 if(BUILD_SDK)
   find_package2(BUNDLED asio
-    VERSION 1.13.0
+    VERSION 1.18.0
   )
   if(NOT asio_FOUND)
     build_bundled(asio extern/asio)
@@ -146,6 +144,8 @@ if(BUILD_FAIRMQ)
   find_package2(PRIVATE ZeroMQ REQUIRED
     VERSION 4.1.4
   )
+  build_bundled(PicoSHA2 extern/PicoSHA2)
+  find_package2(PRIVATE PicoSHA2 REQUIRED)
 endif()
 
 if(BUILD_TESTING)
@@ -258,7 +258,7 @@ install_cmake_package()
 
 # Summary ######################################################################
 message(STATUS "  ")
-message(STATUS "  ${Cyan}CXX STANDARD${CR}       ${BGreen}C++${CMAKE_CXX_STANDARD}${CR} (>= C++${PROJECT_MIN_CXX_STANDARD}, change with ${BMagenta}-DCMAKE_CXX_STANDARD=17${CR})")
+message(STATUS "  ${Cyan}CXX STANDARD${CR}       ${BGreen}C++${CMAKE_CXX_STANDARD}${CR} (>= C++${PROJECT_MIN_CXX_STANDARD}, change with ${BMagenta}-DCMAKE_CXX_STANDARD=20${CR})")
 if(CMAKE_CXX_FLAGS)
   message(STATUS "  ")
   message(STATUS "  ${Cyan}GLOBAL CXX FLAGS${CR}  ${BGreen}${CMAKE_CXX_FLAGS}${CR}")
@@ -361,9 +361,9 @@ else()
 endif()
 message(STATUS "  ${BWhite}tests${CR}              ${tests_summary}")
 if(BUILD_OFI_TRANSPORT)
-  set(ofi_summary "${BGreen}YES${CR}    EXPERIMENTAL (requires C++14) (disable with ${BMagenta}-DBUILD_OFI_TRANSPORT=OFF${CR})")
+  set(ofi_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_OFI_TRANSPORT=OFF${CR})")
 else()
-  set(ofi_summary "${BRed} NO${CR}    EXPERIMENTAL (requires C++14) (default, enable with ${BMagenta}-DBUILD_OFI_TRANSPORT=ON${CR})")
+  set(ofi_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_OFI_TRANSPORT=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}ofi_transport${CR}      ${ofi_summary}")
 if(BUILD_DDS_PLUGIN)
@@ -373,9 +373,9 @@ else()
 endif()
 message(STATUS "  ${BWhite}dds_plugin${CR}         ${dds_summary}")
 if(BUILD_PMIX_PLUGIN)
-  set(pmix_summary "${BGreen}YES${CR}    EXPERIMENTAL (requires C++14) (disable with ${BMagenta}-DBUILD_PMIX_PLUGIN=OFF${CR})")
+  set(pmix_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_PMIX_PLUGIN=OFF${CR})")
 else()
-  set(pmix_summary "${BRed} NO${CR}    EXPERIMENTAL (requires C++14) (default, enable with ${BMagenta}-DBUILD_PMIX_PLUGIN=ON${CR})")
+  set(pmix_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_PMIX_PLUGIN=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}pmix_plugin${CR}        ${pmix_summary}")
 if(BUILD_EXAMPLES)
@@ -391,9 +391,9 @@ else()
 endif()
 message(STATUS "  ${BWhite}docs${CR}               ${docs_summary}")
 if(BUILD_SDK)
-  set(sdk_summary "${BGreen}YES${CR}    EXPERIMENTAL (required C++14) (disable with ${BMagenta}-DBUILD_SDK=OFF${CR})")
+  set(sdk_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_SDK=OFF${CR})")
 else()
-  set(sdk_summary "${BRed} NO${CR}    EXPERIMENTAL (required C++14) (default, enable with ${BMagenta}-DBUILD_SDK=ON${CR})")
+  set(sdk_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_SDK=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}sdk${CR}                ${sdk_summary}")
 if(BUILD_SDK_COMMANDS)
@@ -427,4 +427,10 @@ message(STATUS "  ${Cyan}INSTALL PREFIX${CR}     ${BGreen}${CMAKE_INSTALL_PREFIX
 message(STATUS "  ")
 message(STATUS "  ${Cyan}RUN STATIC ANALYSIS  ${static_ana_summary}")
 message(STATUS "  ")
+if(FAIRMQ_DEBUG_MODE)
+  message(STATUS "  ${Cyan}DEBUG MODE${CR}         ${BGreen}${FAIRMQ_DEBUG_MODE}${CR} (disable with ${BMagenta}-DFAIRMQ_DEBUG_MODE=OFF${CR})")
+else()
+  message(STATUS "  ${Cyan}DEBUG MODE${CR}         ${BRed}${FAIRMQ_DEBUG_MODE}${CR} (enable with ${BMagenta}-DFAIRMQ_DEBUG_MODE=ON${CR})")
+endif()
+message(STATUS "  ")
 ################################################################################

CONTRIBUTORS

@@ -8,5 +8,6 @@ Lebedev, Andrey
 Mrnjavac, Teo <teo.m@cern.ch>
 Neskovic, Gvozden
 Richter, Matthias
+Tacke, Christian
 Uhlig, Florian
 Wenzel, Sandro

COPYRIGHT

@@ -23,6 +23,10 @@ Files: extern/asio
 Copyright: 2003-2019, Christopher M. Kohlhoff (chris at kohlhoff dot com)
 License: BSL-1.0
 
+Files: extern/PicoSHA2
+Copyright: 2017 okdshin
+License: MIT
+
 License: LGPL-3.0-only
   [see LICENSE file]
 
@@ -102,3 +106,22 @@ License: BSL-1.0
   FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   DEALINGS IN THE SOFTWARE.
+
+License: MIT
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

FairMQTest.cmake

@@ -1,85 +1,65 @@
 ################################################################################
-#    Copyright (C) 2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    #
+#    Copyright (C) 2021 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(CTEST_SOURCE_DIRECTORY $ENV{SOURCEDIR})
-Set(CTEST_BINARY_DIRECTORY $ENV{BUILDDIR})
-Set(CTEST_SITE $ENV{SITE})
-Set(CTEST_BUILD_NAME $ENV{LABEL})
-Set(CTEST_CMAKE_GENERATOR "Unix Makefiles")
-Set(CTEST_PROJECT_NAME "FairMQ")
 
-Find_Program(CTEST_GIT_COMMAND NAMES git)
+cmake_host_system_information(RESULT fqdn QUERY FQDN)
-Set(CTEST_UPDATE_COMMAND "${CTEST_GIT_COMMAND}")
 
-Set(BUILD_COMMAND "make")
+set(CTEST_SOURCE_DIRECTORY .)
-Set(CTEST_BUILD_COMMAND "${BUILD_COMMAND} -j$ENV{number_of_processors}")
+set(CTEST_BINARY_DIRECTORY build)
+set(CTEST_CMAKE_GENERATOR "Ninja")
+set(CTEST_USE_LAUNCHERS ON)
+set(CTEST_CONFIGURATION_TYPE "RelWithDebInfo")
 
-String(TOUPPER $ENV{ctest_model} _Model)
+if(NOT NCPUS)
-Set(configure_options "-DCMAKE_BUILD_TYPE=$ENV{ctest_model}")
+  if(ENV{SLURM_CPUS_PER_TASK})
+    set(NCPUS $ENV{SLURM_CPUS_PER_TASK})
+  else()
+    include(ProcessorCount)
+    ProcessorCount(NCPUS)
+    if(NCPUS EQUAL 0)
+      set(NCPUS 1)
+    endif()
+  endif()
+endif()
 
-Set(CTEST_USE_LAUNCHERS 1)
+if ("$ENV{CTEST_SITE}" STREQUAL "")
-Set(configure_options "${configure_options};-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}")
+  set(CTEST_SITE "${fqdn}")
+else()
+  set(CTEST_SITE $ENV{CTEST_SITE})
+endif()
 
-Set(configure_options "${configure_options};-DDISABLE_COLOR=ON")
+if ("$ENV{LABEL}" STREQUAL "")
-Set(configure_options "${configure_options};-DCMAKE_PREFIX_PATH=$ENV{SIMPATH}")
+  set(CTEST_BUILD_NAME "build")
-# Set(configure_options "${configure_options};-DBUILD_OFI_TRANSPORT=ON")
+else()
-Set(configure_options "${configure_options};-DBUILD_DDS_PLUGIN=ON")
+  set(CTEST_BUILD_NAME $ENV{LABEL})
-Set(configure_options "${configure_options};-DBUILD_SDK=ON")
+endif()
-Set(configure_options "${configure_options};-DBUILD_SDK_COMMANDS=ON")
-Set(configure_options "${configure_options};-DFAST_BUILD=ON")
-Set(configure_options "${configure_options};-DCOTIRE_MAXIMUM_NUMBER_OF_UNITY_INCLUDES=-j$ENV{number_of_processors}")
 
-Set(EXTRA_FLAGS $ENV{EXTRA_FLAGS})
+ctest_start(Continuous)
-If(EXTRA_FLAGS)
-  Set(configure_options "${configure_options};${EXTRA_FLAGS}")
-EndIf()
 
-If($ENV{ctest_model} MATCHES Profile)
+list(APPEND options
-  Find_Program(GCOV_COMMAND gcov)
+  "-DDISABLE_COLOR=ON"
-  If(GCOV_COMMAND)
+  "-DBUILD_SDK_COMMANDS=ON"
-    Message("Found GCOV: ${GCOV_COMMAND}")
+  "-DBUILD_SDK=ON"
-    Set(CTEST_COVERAGE_COMMAND ${GCOV_COMMAND})
+  "-DBUILD_DDS_PLUGIN=ON")
-    set(CTEST_COVERAGE_EXTRA_FLAGS "-p")
+if(RUN_STATIC_ANALYSIS)
-  EndIf(GCOV_COMMAND)
+  list(APPEND options "-DRUN_STATIC_ANALYSIS=ON")
-EndIf()
+endif()
+list(JOIN options ";" optionsstr)
+ctest_configure(OPTIONS "${optionsstr}")
 
-If($ENV{ctest_model} MATCHES Nightly OR $ENV{ctest_model} MATCHES Profile)
+ctest_build(FLAGS "-j${NCPUS}")
-  Ctest_Empty_Binary_Directory(${CTEST_BINARY_DIRECTORY})
-EndIf()
 
-Ctest_Start($ENV{ctest_model})
+ctest_test(BUILD "${CTEST_BINARY_DIRECTORY}"
+           PARALLEL_LEVEL 1
+           SCHEDULE_RANDOM ON
+           RETURN_VALUE _ctest_test_ret_val)
 
-Ctest_Configure(BUILD "${CTEST_BINARY_DIRECTORY}"
+ctest_submit()
-                OPTIONS "${configure_options}"
-               )
 
-Ctest_Build(BUILD "${CTEST_BINARY_DIRECTORY}")
+if(_ctest_test_ret_val)
-
-Ctest_Test(BUILD "${CTEST_BINARY_DIRECTORY}"
-           # PARALLEL_LEVEL $ENV{number_of_processors}
-           PARALLEL_LEVEL $ENV{number_of_processors}
-           RETURN_VALUE _ctest_test_ret_val
-          )
-
-If(GCOV_COMMAND)
-  Ctest_Coverage(BUILD "${CTEST_BINARY_DIRECTORY}" LABELS coverage)
-EndIf()
-
-If("$ENV{do_codecov_upload}")
-  Execute_Process(COMMAND curl https://codecov.io/bash -o codecov_uploader.sh
-                  WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY}
-                  TIMEOUT 60)
-  Execute_Process(COMMAND bash ./codecov_uploader.sh -X gcov
-                  WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY}
-                  TIMEOUT 60)
-EndIf()
-
-Ctest_Submit()
-
-if (_ctest_test_ret_val)
   Message(FATAL_ERROR "Some tests failed.")
 endif()

Jenkinsfile

@@ -1,60 +1,63 @@
 #!groovy
 
-def specToLabel(Map spec) {
+def jobMatrix(String type, List specs) {
-  return "${spec.os}-${spec.arch}-${spec.compiler}-FairSoft_${spec.fairsoft}"
-}
-
-def jobMatrix(String prefix, List specs, Closure callback) {
   def nodes = [:]
   for (spec in specs) {
-    def label = specToLabel(spec)
+    job = "${spec.os}-${spec.ver}-${spec.arch}-${spec.compiler}"
-    def fairsoft = spec.fairsoft
+    def label = "${type}/${job}"
+    def selector = "${spec.os}-${spec.ver}-${spec.arch}"
     def os = spec.os
-    def compiler = spec.compiler
+    def ver = spec.ver
-    nodes["${prefix}/${label}"] = {
+    def check = spec.check
-      node(label) {
+
-        githubNotify(context: "${prefix}/${label}", description: 'Building ...', status: 'PENDING')
+    nodes[label] = {
+      node(selector) {
+        githubNotify(context: "${label}", description: 'Building ...', status: 'PENDING')
         try {
           deleteDir()
           checkout scm
 
-          sh """\
+          def jobscript = 'job.sh'
-            echo "export SIMPATH=\${SIMPATH_PREFIX}${fairsoft}" >> Dart.cfg
+          def ctestcmd = "ctest -S FairMQTest.cmake -V --output-on-failure"
-            echo "export FAIRSOFT_VERSION=${fairsoft}" >> Dart.cfg
+          sh "echo \"set -e\" >> ${jobscript}"
-          """
+          sh "echo \"export LABEL=\\\"\${JOB_BASE_NAME} ${label}\\\"\" >> ${jobscript}"
-          if (os =~ /Debian/ && compiler =~ /gcc9/) {
+          if (selector =~ /^macos/) {
-            sh '''\
+            sh """\
-              echo "source /etc/profile.d/modules.sh" >> Dart.cfg
+              echo \"export DDS_ROOT=\\\"\\\$(brew --prefix dds)\\\"\" >> ${jobscript}
-              echo "module use /cvmfs/it.gsi.de/modulefiles" >> Dart.cfg
+              echo \"${ctestcmd}\" >> ${jobscript}
-              echo "module load compiler/gcc/9.1.0" >> Dart.cfg
+            """
-            '''
+            sh "cat ${jobscript}"
-          }
+            sh "bash ${jobscript}"
-          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"
+            def containercmd = "singularity exec -B/shared ${env.SINGULARITY_CONTAINER_ROOT}/fairmq/${os}.${ver}.sif bash -l -c \\\"${ctestcmd} -DRUN_STATIC_ANALYSIS=ON\\\""
+            sh """\
+              echo \"echo \\\"*** Job started at .......: \\\$(date -R)\\\"\" >> ${jobscript}
+              echo \"echo \\\"*** Job ID ...............: \\\${SLURM_JOB_ID}\\\"\" >> ${jobscript}
+              echo \"echo \\\"*** Compute node .........: \\\$(hostname -f)\\\"\" >> ${jobscript}
+              echo \"unset http_proxy\" >> ${jobscript}
+              echo \"unset HTTP_PROXY\" >> ${jobscript}
+              echo \"${containercmd}\" >> ${jobscript}
+            """
+            sh "cat ${jobscript}"
+            sh "test/ci/slurm-submit.sh \"FairMQ \${JOB_BASE_NAME} ${label}\" ${jobscript}"
+
+            withChecks('Static Analysis') {
+              recordIssues(enabledForFailure: true,
+                           tools: [gcc(pattern: 'build/Testing/Temporary/*.log')],
+                           filters: [excludeFile('extern/*'), excludeFile('usr/*')],
+                           skipBlames: true)
+            }
           }
 
-          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=$JOB_BASE_NAME" >> Dart.cfg
-            echo "echo \\\$PATH" >> Dart.cfg
-          '''
-          sh 'cat Dart.cfg'
-
-          callback.call(spec, label)
-
           deleteDir()
-          githubNotify(context: "${prefix}/${label}", description: 'Success', status: 'SUCCESS')
+          githubNotify(context: "${label}", description: 'Success', status: 'SUCCESS')
         } catch (e) {
           def tarball = "${prefix}_${label}_dds_logs.tar.gz"
-          sh "tar czvf ${tarball} -C \${WORKSPACE}/build/test/ .DDS/"
+          sh "tar czvf ${tarball} -C \${WORKSPACE}/build/test .DDS/"
           archiveArtifacts tarball
 
           deleteDir()
-          githubNotify(context: "${prefix}/${label}", description: 'Error', status: 'ERROR')
+          githubNotify(context: "${label}", description: 'Error', status: 'ERROR')
           throw e
         }
       }
@@ -66,26 +69,15 @@ def jobMatrix(String prefix, List specs, Closure callback) {
 pipeline{
   agent none
   stages {
-    stage("Run CI Matrix") {
+    stage("CI") {
       steps{
         script {
-          def build_jobs = jobMatrix('build', [
+          def builds = jobMatrix('build', [
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc9.1.0',        fairsoft: 'fairmq_dev'],
+            [os: 'fedora', ver: '32',    arch: 'x86_64', compiler: 'gcc-10'],
-            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM10.0.0', fairsoft: 'fairmq_dev'],
+            [os: 'macos',  ver: '11',    arch: 'x86_64', compiler: 'apple-clang-12'],
-            [os: 'MacOS10.14', arch: 'x86_64', compiler: 'AppleLLVM10.0.0', fairsoft: 'fairmq_dev'],
+          ])
-          ]) { spec, label ->
-            sh './Dart.sh alfa_ci Dart.cfg'
-          }
 
-          def profile_jobs = jobMatrix('codecov', [
+          parallel(builds)
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc9.1.0',        fairsoft: 'fairmq_dev'],
-          ]) { spec, label ->
-            withCredentials([string(credentialsId: 'fairmq_codecov_token', variable: 'CODECOV_TOKEN')]) {
-              sh './Dart.sh codecov Dart.cfg'
-            }
-          }
-
-          parallel(build_jobs + profile_jobs)
         }
       }
     }

Jenkinsfile.nightly

@@ -1,81 +0,0 @@
-#!groovy
-
-def specToLabel(Map spec) {
-  return "${spec.os}-${spec.arch}-${spec.compiler}-FairSoft_${spec.fairsoft}"
-}
-
-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 =~ /gcc9/) {
-            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/9.1.0" >> 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()
-        } catch (e) {
-          def tarball = "${label}_dds_logs.tar.gz"
-          sh "tar czvf ${tarball} -C \${WORKSPACE}/build/test/ .DDS/"
-          archiveArtifacts tarball
-
-          deleteDir()
-          throw e
-        }
-      }
-    }
-  }
-  return nodes
-}
-
-pipeline{
-  agent none
-  triggers { cron('H 2 * * *') }
-  stages {
-    stage("Run Nightly Build/Test Matrix") {
-      steps{
-        script {
-          parallel(buildMatrix([
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc9.1.0',        fairsoft: 'fairmq_dev'],
-            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM10.0.0', fairsoft: 'fairmq_dev'],
-            [os: 'MacOS10.14', arch: 'x86_64', compiler: 'AppleLLVM10.0.0', fairsoft: 'fairmq_dev'],
-          ]) { spec, label ->
-            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) [![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)
+# 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/dev)](https://alfa-ci.gsi.de/blue/organizations/jenkins/FairRootGroup%2FFairMQ/branches) [![Coverity Badge](https://alfa-ci.gsi.de/shields/coverity/scan/fairrootgroup-fairmq.svg)](https://scan.coverity.com/projects/fairrootgroup-fairmq)
 
 C++ Message Queuing Library and Framework
 

cmake/FairMQLib.cmake

@@ -145,7 +145,7 @@ macro(set_fairmq_defaults)
   # Configure build types
   set(CMAKE_CONFIGURATION_TYPES "Debug" "Release" "RelWithDebInfo" "Nightly" "Profile" "Experimental" "AddressSan" "ThreadSan")
   set(_warnings "-Wshadow -Wall -Wextra -Wpedantic")
-  set(CMAKE_CXX_FLAGS_DEBUG          "-g ${_warnings}")
+  set(CMAKE_CXX_FLAGS_DEBUG          "-Og -g ${_warnings}")
   set(CMAKE_CXX_FLAGS_RELEASE        "-O2 -DNDEBUG")
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g ${_warnings} -DNDEBUG")
   set(CMAKE_CXX_FLAGS_NIGHTLY        "-O2 -g ${_warnings}")
@@ -498,6 +498,8 @@ function(build_bundled package bundle)
     set(${package}_BUILD_INCLUDE_DIR ${${package}_SOURCE_DIR}/asio/include CACHE PATH "Bundled ${package} build-interface include dir")
     set(${package}_INSTALL_INCLUDE_DIR ${PROJECT_INSTALL_INCDIR}/bundled CACHE PATH "Bundled ${package} install-interface include dir")
     set(${package}_ROOT ${${package}_SOURCE_DIR}/asio)
+  elseif(${package} STREQUAL PicoSHA2)
+    set(${package}_ROOT ${${package}_SOURCE_DIR})
   endif()
 
   string(TOUPPER ${package} package_upper)

cmake/FindPMIx.cmake

@@ -6,28 +6,35 @@
 #                  copied verbatim in the file "LICENSE"                       #
 ################################################################################
 
+
+# The "lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix" part in all
+# the PATH_SUFFIXES is here to be able to find Debian's
+# libpmix-dev package. It installs everything below
+# /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix
+
+
 find_path(PMIx_INCLUDE_DIR
   NAMES pmix.h
   HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES include
+  PATH_SUFFIXES include lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/include
 )
 
 find_path(PMIx_LIBRARY_DIR
   NAMES libpmix.dylib libpmix.so
   HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES lib lib64
+  PATH_SUFFIXES lib lib64 lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/lib
 )
 
 find_library(PMIx_LIBRARY_SHARED
   NAMES libpmix.dylib libpmix.so
   HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES lib lib64
+  PATH_SUFFIXES lib lib64 lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/lib
 )
 
 find_file(PMIx_VERSION_FILE
   NAMES pmix_version.h
   HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES include
+  PATH_SUFFIXES include lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/include
 )
 
 file(READ "${PMIx_VERSION_FILE}" __version_raw)

cmake/FindPicoSHA2.cmake

@@ -0,0 +1,21 @@
+################################################################################
+#    Copyright (C) 2020 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"                       #
+################################################################################
+
+find_path(PicoSHA2_INCLUDE_DIR NAMES picosha2.h)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PicoSHA2
+  REQUIRED_VARS PicoSHA2_INCLUDE_DIR
+)
+
+if(PicoSHA2_FOUND)
+  add_library(PicoSHA2 INTERFACE IMPORTED)
+  set_target_properties(PicoSHA2 PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${PicoSHA2_INCLUDE_DIR}"
+  )
+endif()

examples/1-1/CMakeLists.txt

@@ -7,10 +7,10 @@
 ################################################################################
 
 add_library(Example11Lib STATIC
-    "Sampler.cxx"
+  "Sampler.cxx"
-    "Sampler.h"
+  "Sampler.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(Example11Lib PUBLIC FairMQ)
@@ -40,12 +40,12 @@ set_tests_properties(Example.1-1.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true P
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-1-1-sampler
+  fairmq-ex-1-1-sampler
-    fairmq-ex-1-1-sink
+  fairmq-ex-1-1-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -54,7 +54,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-1-1.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-1-1.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-1-1.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-1-1.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-1-1.sh
+  RENAME fairmq-start-ex-1-1.sh
 )

examples/1-1/Sampler.cxx

@@ -17,8 +17,7 @@ Sampler::Sampler()
     : fText()
     , fMaxIterations(0)
     , fNumIterations(0)
-{
+{}
-}
 
 void Sampler::InitTask()
 {
@@ -32,25 +31,22 @@ bool Sampler::ConditionalRun()
     // create a copy of the data with new(), that will be deleted after the transfer is complete
     string* text = new string(fText);
 
-    // create message object with a pointer to the data buffer,
+    // create message object with a pointer to the data buffer, its size,
-    // its size,
     // custom deletion function (called when transfer is done),
     // and pointer to the object managing the data buffer
-    FairMQMessagePtr msg(NewMessage(const_cast<char*>(text->c_str()),
+    FairMQMessagePtr msg(NewMessage(
-                                    text->length(),
+        const_cast<char*>(text->c_str()),
-                                    [](void* /*data*/, void* object) { delete static_cast<string*>(object); },
+        text->length(),
-                                    text));
+        [](void* /*data*/, void* object) { delete static_cast<string*>(object); },
+        text));
 
     LOG(info) << "Sending \"" << fText << "\"";
 
-    // in case of error or transfer interruption, return false to go to IDLE state
+    // in case of error or transfer interruption, return false to go to the Ready state
     // successfull transfer will return number of bytes transfered (can be 0 if sending an empty message).
-    if (Send(msg, "data") < 0)
+    if (Send(msg, "data") < 0) {
-    {
         return false;
-    }
+    } else if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations) {
-    else if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations)
-    {
         LOG(info) << "Configured maximum number of iterations reached. Leaving RUNNING state.";
         return false;
     }
@@ -58,8 +54,6 @@ bool Sampler::ConditionalRun()
     return true;
 }
 
-Sampler::~Sampler()
+Sampler::~Sampler() {}
-{
-}
 
 } // namespace example_1_1

examples/1-1/Sink.cxx

@@ -33,23 +33,22 @@ void Sink::InitTask()
     fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 }
 
-// handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
+// handler is called whenever a message arrives on "data", with a reference to the message and a
+// sub-channel index (here 0)
 bool Sink::HandleData(FairMQMessagePtr& msg, int /*index*/)
 {
     LOG(info) << "Received: \"" << string(static_cast<char*>(msg->GetData()), msg->GetSize()) << "\"";
 
-    if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations)
+    if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations) {
-    {
         LOG(info) << "Configured maximum number of iterations reached. Leaving RUNNING state.";
         return false;
     }
 
-    // return true if want to be called again (otherwise return false go to IDLE state)
+    // return true if you want the handler to be called again (otherwise return false go to the
+    // Ready state)
     return true;
 }
 
-Sink::~Sink()
+Sink::~Sink() {}
-{
-}
 
 } // namespace example_1_1

examples/1-n-1/CMakeLists.txt

@@ -7,12 +7,12 @@
 ################################################################################
 
 add_library(Example1N1Lib STATIC
-    "Sampler.cxx"
+  "Sampler.cxx"
-    "Sampler.h"
+  "Sampler.h"
-    "Processor.cxx"
+  "Processor.cxx"
-    "Processor.h"
+  "Processor.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(Example1N1Lib PUBLIC FairMQ)
@@ -48,13 +48,13 @@ set_tests_properties(Example.1-n-1.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-1-n-1-sampler
+  fairmq-ex-1-n-1-sampler
-    fairmq-ex-1-n-1-processor
+  fairmq-ex-1-n-1-processor
-    fairmq-ex-1-n-1-sink
+  fairmq-ex-1-n-1-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -64,12 +64,12 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-1-n-1.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-1-n-1.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-1-n-1.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-1-n-1.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-1-n-1.sh
+  RENAME fairmq-start-ex-1-n-1.sh
 )
 
 install(
-    FILES ${CMAKE_CURRENT_BINARY_DIR}/ex-1-n-1.json
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/ex-1-n-1.json
-    DESTINATION ${PROJECT_INSTALL_DATADIR}
+  DESTINATION ${PROJECT_INSTALL_DATADIR}
 )

examples/builtin-devices/CMakeLists.txt

@@ -34,7 +34,7 @@ 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
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-builtin-devices.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-builtin-devices.sh
+  RENAME fairmq-start-ex-builtin-devices.sh
 )

examples/copypush/CMakeLists.txt

@@ -7,10 +7,10 @@
 ################################################################################
 
 add_library(ExampleCopyPushLib STATIC
-    "Sampler.cxx"
+  "Sampler.cxx"
-    "Sampler.h"
+  "Sampler.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(ExampleCopyPushLib PUBLIC FairMQ)
@@ -41,12 +41,12 @@ set_tests_properties(Example.CopyPush.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL t
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-copypush-sampler
+  fairmq-ex-copypush-sampler
-    fairmq-ex-copypush-sink
+  fairmq-ex-copypush-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -55,7 +55,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-copypush.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-copypush.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-copypush.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-copypush.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-copypush.sh
+  RENAME fairmq-start-ex-copypush.sh
 )

examples/dds/CMakeLists.txt

@@ -29,7 +29,7 @@ target_link_libraries(fairmq-ex-dds-sink PRIVATE ExampleDDSLib)
 add_custom_target(ExampleDDS DEPENDS fairmq-ex-dds-sampler fairmq-ex-dds-processor fairmq-ex-dds-sink)
 
 list(JOIN Boost_LIBRARY_DIRS ":" LIB_DIR)
-set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/plugins/DDS)
+set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/sdk)
 set(DATA_DIR ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-topology.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology.xml @ONLY)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-dds-topology-infinite.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-dds-topology-infinite.xml @ONLY)

examples/multipart/CMakeLists.txt

@@ -7,10 +7,10 @@
  ################################################################################
 
 add_library(ExampleMultipartLib STATIC
-    "Sampler.cxx"
+  "Sampler.cxx"
-    "Sampler.h"
+  "Sampler.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(ExampleMultipartLib PUBLIC FairMQ)
@@ -45,12 +45,12 @@ endif()
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-multipart-sampler
+  fairmq-ex-multipart-sampler
-    fairmq-ex-multipart-sink
+  fairmq-ex-multipart-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -59,7 +59,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-multipart.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multipart.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multipart.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multipart.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-multipart.sh
+  RENAME fairmq-start-ex-multipart.sh
 )

examples/multiple-channels/CMakeLists.txt

@@ -7,12 +7,12 @@
  ################################################################################
 
 add_library(ExampleMultipleChannelsLib STATIC
-    "Sampler.cxx"
+  "Sampler.cxx"
-    "Sampler.h"
+  "Sampler.h"
-    "Broadcaster.cxx"
+  "Broadcaster.cxx"
-    "Broadcaster.h"
+  "Broadcaster.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(ExampleMultipleChannelsLib PUBLIC FairMQ)
@@ -42,13 +42,13 @@ set_tests_properties(Example.MultipleChannels.zeromq PROPERTIES TIMEOUT "30" RUN
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-multiple-channels-sampler
+  fairmq-ex-multiple-channels-sampler
-    fairmq-ex-multiple-channels-broadcaster
+  fairmq-ex-multiple-channels-broadcaster
-    fairmq-ex-multiple-channels-sink
+  fairmq-ex-multiple-channels-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -57,7 +57,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-multiple-channels.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multiple-channels.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multiple-channels.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multiple-channels.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-multiple-channels.sh
+  RENAME fairmq-start-ex-multiple-channels.sh
 )

examples/multiple-transports/CMakeLists.txt

@@ -7,12 +7,12 @@
  ################################################################################
 
 add_library(ExampleMultipleTransportsLib STATIC
-    "Sampler1.cxx"
+  "Sampler1.cxx"
-    "Sampler1.h"
+  "Sampler1.h"
-    "Sampler2.cxx"
+  "Sampler2.cxx"
-    "Sampler2.h"
+  "Sampler2.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(ExampleMultipleTransportsLib PUBLIC FairMQ)
@@ -41,13 +41,13 @@ set_tests_properties(Example.MultipleTransports PROPERTIES TIMEOUT "30" RUN_SERI
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-multiple-transports-sampler1
+  fairmq-ex-multiple-transports-sampler1
-    fairmq-ex-multiple-transports-sampler2
+  fairmq-ex-multiple-transports-sampler2
-    fairmq-ex-multiple-transports-sink
+  fairmq-ex-multiple-transports-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for install directories
@@ -56,7 +56,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-multiple-transports.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multiple-transports.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multiple-transports.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-multiple-transports.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-multiple-transports.sh
+  RENAME fairmq-start-ex-multiple-transports.sh
 )

examples/n-m/CMakeLists.txt

@@ -18,7 +18,7 @@ target_link_libraries(fairmq-ex-n-m-receiver PRIVATE FairMQ)
 add_custom_target(ExampleNM DEPENDS fairmq-ex-n-m-synchronizer fairmq-ex-n-m-sender fairmq-ex-n-m-receiver)
 
 list(JOIN Boost_LIBRARY_DIRS ":" LIB_DIR)
-set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/plugins/DDS)
+set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/sdk)
 set(DATA_DIR ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-n-m-topology.xml                ${CMAKE_CURRENT_BINARY_DIR}/ex-n-m-topology.xml @ONLY)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-n-m-pair-topology.xml           ${CMAKE_CURRENT_BINARY_DIR}/ex-n-m-pair-topology.xml @ONLY)

examples/n-m/ex-n-m-pair-topology.xml

@@ -10,7 +10,7 @@
         <exe reachable="true">fairmq-ex-n-m-synchronizer --id sync --rate 100 --color false -P dds --channel-config name=sync,type=pub,method=bind</exe>
         <env reachable="false">fairmq-ex-n-m-env.sh</env>
         <properties>
-            <name access="write">fmqchan_sync</id>
+            <name access="write">fmqchan_sync</name>
         </properties>
     </decltask>
 
@@ -18,8 +18,8 @@
         <exe reachable="true">fairmq-ex-n-m-sender --id sender%taskIndex% --timeframe-size 100000 --num-receivers ${numReceivers} --color false -P dds --channel-config name=sync,type=sub,method=connect name=data,type=pair,method=connect,numSockets=${numReceivers} --dds-i data:%taskIndex%</exe>
         <env reachable="false">fairmq-ex-n-m-env.sh</env>
         <properties>
-            <name access="read">fmqchan_sync</id>
+            <name access="read">fmqchan_sync</name>
-            <name access="read">fmqchan_data</id>
+            <name access="read">fmqchan_data</name>
         </properties>
     </decltask>
 
@@ -27,7 +27,7 @@
         <exe reachable="true">fairmq-ex-n-m-receiver --id receiver%taskIndex% --num-senders ${numSenders} --color false -P dds --max-timeframes 10 --channel-config name=data,type=pair,method=bind,numSockets=${numSenders}</exe>
         <env reachable="false">fairmq-ex-n-m-env.sh</env>
         <properties>
-            <name access="write">fmqchan_data</id>
+            <name access="write">fmqchan_data</name>
         </properties>
     </decltask>
 

examples/n-m/ex-n-m-topology.xml

@@ -10,7 +10,7 @@
         <exe reachable="true">fairmq-ex-n-m-synchronizer --id sync --rate 100 --color false -P dds --channel-config name=sync,type=pub,method=bind</exe>
         <env reachable="false">fairmq-ex-n-m-env.sh</env>
         <properties>
-            <name access="write">fmqchan_sync</id>
+            <name access="write">fmqchan_sync</name>
         </properties>
     </decltask>
 
@@ -18,8 +18,8 @@
         <exe reachable="true">fairmq-ex-n-m-sender --id sender%taskIndex% --timeframe-size 100000 --num-receivers ${numReceivers} --color false -P dds --channel-config name=sync,type=sub,method=connect name=data,type=push,method=connect,numSockets=${numReceivers}</exe>
         <env reachable="false">fairmq-ex-n-m-env.sh</env>
         <properties>
-            <name access="read">fmqchan_sync</id>
+            <name access="read">fmqchan_sync</name>
-            <name access="read">fmqchan_data</id>
+            <name access="read">fmqchan_data</name>
         </properties>
     </decltask>
 
@@ -27,7 +27,7 @@
         <exe reachable="true">fairmq-ex-n-m-receiver --id receiver%taskIndex% --num-senders ${numSenders} --color false -P dds --max-timeframes 10 --channel-config name=data,type=pull,method=bind</exe>
         <env reachable="false">fairmq-ex-n-m-env.sh</env>
         <properties>
-            <name access="write">fmqchan_data</id>
+            <name access="write">fmqchan_data</name>
         </properties>
     </decltask>
 

examples/qc/CMakeLists.txt

@@ -21,7 +21,7 @@ target_link_libraries(fairmq-ex-qc-sink PRIVATE FairMQ)
 add_custom_target(ExampleQC DEPENDS fairmq-ex-qc-sampler fairmq-ex-qc-dispatcher fairmq-ex-qc-task fairmq-ex-qc-sink)
 
 list(JOIN Boost_LIBRARY_DIRS ":" LIB_DIR)
-set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/plugins/DDS)
+set(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_BINARY_DIR}/fairmq/sdk)
 set(DATA_DIR ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ex-qc-topology.xml ${CMAKE_CURRENT_BINARY_DIR}/ex-qc-topology.xml @ONLY)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-ex-qc-env.sh ${CMAKE_CURRENT_BINARY_DIR}/fairmq-ex-qc-env.sh @ONLY)

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

@@ -51,7 +51,7 @@ fairmq-dds-command-ui -c k
 fairmq-dds-command-ui -c b
 fairmq-dds-command-ui -c x
 fairmq-dds-command-ui -c j
-allexceptqctasks="main/(Sampler|QCDispatcher|Sink)"
+allexceptqctasks="main/(Sampler|QCDispatcher|Sink).*"
 fairmq-dds-command-ui -c r -p $allexceptqctasks
 qctask="main/QCTask.*"
 qcdispatcher="main/QCDispatcher.*"

examples/readout/CMakeLists.txt

@@ -29,15 +29,15 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-readout-processing.sh
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-readout-readout
+  fairmq-ex-readout-readout
-    fairmq-ex-readout-builder
+  fairmq-ex-readout-builder
-    fairmq-ex-readout-processor
+  fairmq-ex-readout-processor
-    fairmq-ex-readout-sender
+  fairmq-ex-readout-sender
-    fairmq-ex-readout-receiver
+  fairmq-ex-readout-receiver
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -47,13 +47,13 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-readout.sh.in ${CMAKE
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-readout-processing.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-readout-processing.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-readout.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-readout.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-readout.sh
+  RENAME fairmq-start-ex-readout.sh
 )
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-readout-processing.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-readout-processing.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-readout-processing.sh
+  RENAME fairmq-start-ex-readout-processing.sh
 )

examples/region/CMakeLists.txt

@@ -7,10 +7,10 @@
  ################################################################################
 
 add_library(ExampleRegionLib STATIC
-    "Sampler.cxx"
+  "Sampler.cxx"
-    "Sampler.h"
+  "Sampler.h"
-    "Sink.cxx"
+  "Sink.cxx"
-    "Sink.h"
+  "Sink.h"
 )
 
 target_link_libraries(ExampleRegionLib PUBLIC FairMQ)
@@ -40,12 +40,12 @@ set_tests_properties(Example.Region.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL tru
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-region-sampler
+  fairmq-ex-region-sampler
-    fairmq-ex-region-sink
+  fairmq-ex-region-sink
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -54,7 +54,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-region.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-region.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-region.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-region.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-region.sh
+  RENAME fairmq-start-ex-region.sh
 )

examples/region/Sampler.cxx

@@ -23,36 +23,41 @@ namespace example_region
 
 Sampler::Sampler()
     : fMsgSize(10000)
+    , fLinger(100)
     , fMaxIterations(0)
     , fNumIterations(0)
     , fRegion(nullptr)
     , fNumUnackedMsgs(0)
-{
+{}
-}
 
 void Sampler::InitTask()
 {
     fMsgSize = fConfig->GetProperty<int>("msg-size");
+    fLinger = fConfig->GetProperty<uint32_t>("region-linger");
     fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
 
     fChannels.at("data").at(0).Transport()->SubscribeToRegionEvents([](FairMQRegionInfo info) {
-        LOG(warn) << ">>>" << info.event;
+        LOG(info) << "Region event: " << info.event
-        LOG(warn) << "id: " << info.id;
+                  << ", managed: " << info.managed
-        LOG(warn) << "ptr: " << info.ptr;
+                  << ", id: " << info.id
-        LOG(warn) << "size: " << info.size;
+                  << ", ptr: " << info.ptr
-        LOG(warn) << "flags: " << info.flags;
+                  << ", size: " << info.size
+                  << ", flags: " << info.flags;
     });
 
     fRegion = FairMQUnmanagedRegionPtr(NewUnmanagedRegionFor("data",
                                                              0,
                                                              10000000,
                                                              [this](const std::vector<fair::mq::RegionBlock>& blocks) { // callback to be called when message buffers no longer needed by transport
+                                                                 lock_guard<mutex> lock(fMtx);
                                                                  fNumUnackedMsgs -= blocks.size();
+
                                                                  if (fMaxIterations > 0) {
-                                                                    LOG(debug) << "Received " << blocks.size() << " acks";
+                                                                    LOG(info) << "Received " << blocks.size() << " acks";
                                                                  }
                                                              }
                                                              ));
+    fRegion->SetLinger(fLinger);
 }
 
 bool Sampler::ConditionalRun()
@@ -69,27 +74,30 @@ bool Sampler::ConditionalRun()
     // LOG(info) << "check: " << static_cast<char*>(fRegion->GetData())[3];
     // std::this_thread::sleep_for(std::chrono::seconds(1));
 
+    lock_guard<mutex> lock(fMtx);
     if (Send(msg, "data", 0) > 0) {
-        ++fNumUnackedMsgs;
-
         if (fMaxIterations > 0 && ++fNumIterations >= fMaxIterations) {
             LOG(info) << "Configured maximum number of iterations reached. Leaving RUNNING state.";
             return false;
         }
     }
+    ++fNumUnackedMsgs;
 
     return true;
 }
 
 void Sampler::ResetTask()
 {
-    // if not all messages acknowledged, wait for a bit. But only once, since receiver could be already dead.
+    // On destruction UnmanagedRegion will try to TODO
-    if (fNumUnackedMsgs != 0) {
-        LOG(debug) << "waiting for all acknowledgements... (" << fNumUnackedMsgs << ")";
-        this_thread::sleep_for(chrono::milliseconds(500));
-        LOG(debug) << "done, still unacked: " << fNumUnackedMsgs;
-    }
     fRegion.reset();
+    {
+        lock_guard<mutex> lock(fMtx);
+        if (fNumUnackedMsgs != 0) {
+            LOG(info) << "Done, still not acknowledged: " << fNumUnackedMsgs;
+        } else {
+            LOG(info) << "All acknowledgements received.";
+        }
+    }
     fChannels.at("data").at(0).Transport()->UnsubscribeFromRegionEvents();
 }
 

examples/region/Sampler.h

@@ -15,7 +15,8 @@
 #ifndef FAIRMQEXAMPLEREGIONSAMPLER_H
 #define FAIRMQEXAMPLEREGIONSAMPLER_H
 
-#include <atomic>
+#include <mutex>
+#include <cstdint>
 
 #include "FairMQDevice.h"
 
@@ -35,10 +36,12 @@ class Sampler : public FairMQDevice
 
   private:
     int fMsgSize;
+    uint32_t fLinger;
     uint64_t fMaxIterations;
     uint64_t fNumIterations;
     FairMQUnmanagedRegionPtr fRegion;
-    std::atomic<uint64_t> fNumUnackedMsgs;
+    std::mutex fMtx;
+    uint64_t fNumUnackedMsgs;
 };
 
 } // namespace example_region

examples/region/Sink.cxx

@@ -30,11 +30,12 @@ void Sink::InitTask()
     // Get the fMaxIterations value from the command line options (via fConfig)
     fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
     fChannels.at("data").at(0).Transport()->SubscribeToRegionEvents([](FairMQRegionInfo info) {
-        LOG(warn) << ">>>" << info.event;
+        LOG(info) << "Region event: " << info.event
-        LOG(warn) << "id: " << info.id;
+                  << ", managed: " << info.managed
-        LOG(warn) << "ptr: " << info.ptr;
+                  << ", id: " << info.id
-        LOG(warn) << "size: " << info.size;
+                  << ", ptr: " << info.ptr
-        LOG(warn) << "flags: " << info.flags;
+                  << ", size: " << info.size
+                  << ", flags: " << info.flags;
     });
 }
 

examples/region/runSampler.cxx

@@ -15,6 +15,7 @@ void addCustomOptions(bpo::options_description& options)
 {
     options.add_options()
         ("msg-size", bpo::value<int>()->default_value(1000), "Message size in bytes")
+        ("region-linger", bpo::value<uint32_t>()->default_value(100), "Linger period for regions")
         ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Maximum number of iterations of Run/ConditionalRun/OnData (0 - infinite)");
 }
 

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

@@ -23,6 +23,7 @@ SAMPLER+=" --verbosity veryhigh"
 SAMPLER+=" --control static --color false"
 SAMPLER+=" --max-iterations 1"
 SAMPLER+=" --msg-size $msgSize"
+SAMPLER+=" --region-linger 500"
 SAMPLER+=" --channel-config name=data,type=push,method=bind,address=tcp://127.0.0.1:7777"
 @CMAKE_CURRENT_BINARY_DIR@/$SAMPLER &
 SAMPLER_PID=$!

examples/req-rep/CMakeLists.txt

@@ -7,10 +7,10 @@
  ################################################################################
 
 add_library(ExampleReqRepLib STATIC
-    "Client.cxx"
+  "Client.cxx"
-    "Client.h"
+  "Client.h"
-    "Server.cxx"
+  "Server.cxx"
-    "Server.h"
+  "Server.h"
 )
 
 target_link_libraries(ExampleReqRepLib PUBLIC FairMQ)
@@ -41,12 +41,12 @@ set_tests_properties(Example.ReqRep.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL tru
 # install
 
 install(
-    TARGETS
+  TARGETS
-    fairmq-ex-req-rep-client
+  fairmq-ex-req-rep-client
-    fairmq-ex-req-rep-server
+  fairmq-ex-req-rep-server
 
-    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
+  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )
 
 # configure run script with different executable paths for build and for install directories
@@ -55,7 +55,7 @@ set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-req-rep.sh.in ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-req-rep.sh_install)
 
 install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-req-rep.sh_install
+  PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/fairmq-start-ex-req-rep.sh_install
-    DESTINATION ${PROJECT_INSTALL_BINDIR}
+  DESTINATION ${PROJECT_INSTALL_BINDIR}
-    RENAME fairmq-start-ex-req-rep.sh
+  RENAME fairmq-start-ex-req-rep.sh
 )

fairmq/CMakeLists.txt

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (C) 2012-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
+# Copyright (C) 2012-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
 #                                                                              #
 #              This software is distributed under the terms of the             #
 #              GNU Lesser General Public Licence (LGPL) version 3,             #
@@ -62,6 +62,7 @@ if(BUILD_FAIRMQ OR BUILD_SDK)
   target_link_libraries(${target}
     PRIVATE
     FairLogger::FairLogger
+    Threads::Threads
     PUBLIC
     Boost::boost
   )
@@ -145,6 +146,7 @@ if(BUILD_FAIRMQ)
   # libFairMQ header files #
   ##########################
   set(FAIRMQ_PUBLIC_HEADER_FILES
+    Device.h
     DeviceRunner.h
     EventManager.h
     FairMQChannel.h
@@ -169,19 +171,21 @@ if(BUILD_FAIRMQ)
     Plugin.h
     PluginManager.h
     PluginServices.h
+    runDevice.h
     runFairMQDevice.h
+    shmem/Monitor.h
   )
 
   set(FAIRMQ_PRIVATE_HEADER_FILES
-    devices/FairMQBenchmarkSampler.h
+    devices/BenchmarkSampler.h
-    devices/FairMQMerger.h
+    devices/Merger.h
-    devices/FairMQMultiplier.h
+    devices/Multiplier.h
-    devices/FairMQProxy.h
+    devices/Proxy.h
-    devices/FairMQSink.h
+    devices/Sink.h
-    devices/FairMQSplitter.h
+    devices/Splitter.h
     plugins/Builtin.h
     plugins/config/Config.h
-    plugins/Control.h
+    plugins/control/Control.h
     shmem/Message.h
     shmem/Poller.h
     shmem/UnmanagedRegion.h
@@ -220,10 +224,6 @@ if(BUILD_FAIRMQ)
     FairMQPoller.cxx
     FairMQSocket.cxx
     FairMQTransportFactory.cxx
-    devices/FairMQMerger.cxx
-    devices/FairMQMultiplier.cxx
-    devices/FairMQProxy.cxx
-    devices/FairMQSplitter.cxx
     Plugin.cxx
     PluginManager.cxx
     PluginServices.cxx
@@ -232,8 +232,9 @@ if(BUILD_FAIRMQ)
     Properties.cxx
     SuboptParser.cxx
     plugins/config/Config.cxx
-    plugins/Control.cxx
+    plugins/control/Control.cxx
     MemoryResources.cxx
+    shmem/Monitor.cxx
   )
 
   if(BUILD_OFI_TRANSPORT)
@@ -251,7 +252,7 @@ if(BUILD_FAIRMQ)
   # configure files #
   ###################
   set(FAIRMQ_BIN_DIR ${CMAKE_BINARY_DIR}/fairmq)
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/run/startMQBenchmark.sh.in ${CMAKE_CURRENT_BINARY_DIR}/startMQBenchmark.sh)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/devices/startMQBenchmark.sh.in ${CMAKE_CURRENT_BINARY_DIR}/startMQBenchmark.sh)
 
   #################################
   # define libFairMQ build target #
@@ -276,6 +277,9 @@ if(BUILD_FAIRMQ)
   # preprocessor definitions #
   ############################
   target_compile_definitions(${_target} PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
+  if(FAIRMQ_DEBUG_MODE)
+    target_compile_definitions(${_target} PUBLIC FAIRMQ_DEBUG_MODE)
+  endif()
   if(BUILD_OFI_TRANSPORT)
     target_compile_definitions(${_target} PRIVATE BUILD_OFI_TRANSPORT)
   endif()
@@ -325,6 +329,7 @@ if(BUILD_FAIRMQ)
 
     PRIVATE # only libFairMQ links against private dependencies
     libzmq
+    PicoSHA2
     ${OFI_DEPS}
   )
   set_target_properties(${_target} PROPERTIES
@@ -351,39 +356,47 @@ if(BUILD_FAIRMQ)
   ###############
   # executables #
   ###############
-  add_executable(fairmq-bsampler run/runBenchmarkSampler.cxx)
+  add_executable(fairmq-bsampler devices/runBenchmarkSampler.cxx)
   target_link_libraries(fairmq-bsampler FairMQ)
 
-  add_executable(fairmq-merger run/runMerger.cxx)
+  add_executable(fairmq-merger devices/runMerger.cxx)
   target_link_libraries(fairmq-merger FairMQ)
 
-  add_executable(fairmq-multiplier run/runMultiplier.cxx)
+  add_executable(fairmq-multiplier devices/runMultiplier.cxx)
   target_link_libraries(fairmq-multiplier FairMQ)
 
-  add_executable(fairmq-proxy run/runProxy.cxx)
+  add_executable(fairmq-proxy devices/runProxy.cxx)
   target_link_libraries(fairmq-proxy FairMQ)
 
-  add_executable(fairmq-sink run/runSink.cxx)
+  add_executable(fairmq-sink devices/runSink.cxx)
   target_link_libraries(fairmq-sink FairMQ)
 
-  add_executable(fairmq-splitter run/runSplitter.cxx)
+  add_executable(fairmq-splitter devices/runSplitter.cxx)
   target_link_libraries(fairmq-splitter FairMQ)
 
   add_executable(fairmq-shmmonitor shmem/Monitor.cxx shmem/Monitor.h shmem/runMonitor.cxx)
   target_compile_definitions(fairmq-shmmonitor PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
+  if(FAIRMQ_DEBUG_MODE)
+    target_compile_definitions(fairmq-shmmonitor PUBLIC FAIRMQ_DEBUG_MODE)
+  endif()
   target_link_libraries(fairmq-shmmonitor PUBLIC
     Threads::Threads
     $<$<PLATFORM_ID:Linux>:rt>
     Boost::boost
     Boost::date_time
     Boost::program_options
+    FairLogger::FairLogger
+    PicoSHA2
   )
   target_include_directories(fairmq-shmmonitor PUBLIC
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
   )
 
-  add_executable(fairmq-uuid-gen run/runUuidGenerator.cxx)
+  add_executable(fairmq-uuid-gen tools/runUuidGenerator.cxx)
-  target_link_libraries(fairmq-uuid-gen FairMQ)
+  target_link_libraries(fairmq-uuid-gen PUBLIC
+    Boost::program_options
+    Tools
+  )
 
 
   ###########

fairmq/Device.h

@@ -0,0 +1,21 @@
+/********************************************************************************
+ *   Copyright (C) 2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH     *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_DEVICE_H
+#define FAIR_MQ_DEVICE_H
+
+#include <FairMQDevice.h>
+
+namespace fair::mq
+{
+
+    using Device = ::FairMQDevice;
+
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_DEVICE_H */

fairmq/DeviceRunner.cxx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2017-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -8,10 +8,14 @@
 
 #include "DeviceRunner.h"
 
-#include <exception>
+#include <fairmq/tools/Strings.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Version.h>
 #include <fairmq/Version.h>
 
+#include <fairlogger/Logger.h>
+
+#include <exception>
+
 using namespace std;
 using namespace fair::mq;
 
@@ -52,7 +56,13 @@ bool DeviceRunner::HandleGeneralOptions(const fair::mq::ProgOptions& config, boo
             fair::Logger::SetConsoleSeverity("nolog");
         } else {
             fair::Logger::SetConsoleColor(color);
-            fair::Logger::SetConsoleSeverity(severity);
+            auto envFairMQSeverity = getenv("FAIRMQ_SEVERITY");
+            if (envFairMQSeverity) {
+                severity = envFairMQSeverity;
+            }
+            if (severity != "") {
+                fair::Logger::SetConsoleSeverity(severity);
+            }
         }
 
         if (printLogo) {
@@ -150,8 +160,8 @@ auto DeviceRunner::Run() -> int
 
     // Handle --version
     if (fConfig.Count("version")) {
-        cout << "FairMQ version: " << FAIRMQ_GIT_VERSION << endl;
+        LOGV(info, verylow) << "FairMQ version: " << FAIRMQ_GIT_VERSION;
-        cout << "User device version: " << fDevice->GetVersion() << endl;
+        LOGV(info, verylow) << "User device version: " << fDevice->GetVersion();
         fDevice->ChangeState(fair::mq::Transition::End);
         return 0;
     }

fairmq/DeviceRunner.h

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2017-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -9,19 +9,18 @@
 #ifndef FAIR_MQ_DEVICERUNNER_H
 #define FAIR_MQ_DEVICERUNNER_H
 
+#include <fairmq/Device.h>
 #include <fairmq/EventManager.h>
 #include <fairmq/PluginManager.h>
 #include <fairmq/ProgOptions.h>
-#include <FairMQDevice.h>
-#include <FairMQLogger.h>
 
 #include <functional>
 #include <memory>
 #include <string>
 #include <vector>
 
-namespace fair {
+namespace fair::mq
-namespace mq {
+{
 
 /**
  * @class DeviceRunner DeviceRunner.h <fairmq/DeviceRunner.h>
@@ -74,7 +73,7 @@ class DeviceRunner
 
     std::vector<std::string> fRawCmdLineArgs;
     fair::mq::ProgOptions fConfig;
-    std::unique_ptr<FairMQDevice> fDevice;
+    std::unique_ptr<Device> fDevice;
     PluginManager fPluginManager;
     const bool fPrintLogo;
 
@@ -89,7 +88,6 @@ struct ModifyRawCmdLineArgs : Event<DeviceRunner&> {};
 struct InstantiateDevice : Event<DeviceRunner&> {};
 } /* namespace hooks */
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIR_MQ_DEVICERUNNER_H */

fairmq/EventManager.h

@@ -21,9 +21,7 @@
 #include <boost/functional/hash.hpp>
 #include <boost/signals2.hpp>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 // Inherit from this base event type to create custom event types
@@ -137,7 +135,6 @@ class EventManager
     }
 }; /* class EventManager */
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIR_MQ_EVENTMANAGER_H */

fairmq/FairMQChannel.cxx

@@ -7,11 +7,15 @@
  ********************************************************************************/
 
 #include "FairMQChannel.h"
+
 #include <fairmq/tools/Strings.h>
 #include <fairmq/Properties.h>
 
+#include <fairlogger/Logger.h>
+
 #include <boost/algorithm/string.hpp> // join/split
 
+#include <cstddef> // size_t
 #include <regex>
 #include <set>
 #include <random>
@@ -77,31 +81,30 @@ FairMQChannel::FairMQChannel(const string& name, const string& type, const strin
     , fPortRangeMin(DefaultPortRangeMin)
     , fPortRangeMax(DefaultPortRangeMax)
     , fAutoBind(DefaultAutoBind)
-    , fIsValid(false)
+    , fValid(false)
     , fMultipart(false)
-    , fModified(true)
+{
-    , fReset(false)
+    // LOG(warn) << "Constructing channel '" << fName << "'";
-    , fMtx()
+}
-{}
 
 FairMQChannel::FairMQChannel(const string& name, int index, const fair::mq::Properties& properties)
     : FairMQChannel(tools::ToString(name, "[", index, "]"), "unspecified", "unspecified", "unspecified", nullptr)
 {
     string prefix(tools::ToString("chans.", name, ".", index, "."));
 
-    fType = GetPropertyOrDefault(properties, string(prefix + "type"), fType);
+    fType = GetPropertyOrDefault(properties, string(prefix + "type"), std::string(DefaultType));
-    fMethod = GetPropertyOrDefault(properties, string(prefix + "method"), fMethod);
+    fMethod = GetPropertyOrDefault(properties, string(prefix + "method"), std::string(DefaultMethod));
-    fAddress = GetPropertyOrDefault(properties, string(prefix + "address"), fAddress);
+    fAddress = GetPropertyOrDefault(properties, string(prefix + "address"), std::string(DefaultAddress));
-    fTransportType = TransportTypes.at(GetPropertyOrDefault(properties, string(prefix + "transport"), TransportNames.at(fTransportType)));
+    fTransportType = TransportType(GetPropertyOrDefault(properties, string(prefix + "transport"), std::string(DefaultTransportName)));
-    fSndBufSize = GetPropertyOrDefault(properties, string(prefix + "sndBufSize"), fSndBufSize);
+    fSndBufSize = GetPropertyOrDefault(properties, string(prefix + "sndBufSize"), DefaultSndBufSize);
-    fRcvBufSize = GetPropertyOrDefault(properties, string(prefix + "rcvBufSize"), fRcvBufSize);
+    fRcvBufSize = GetPropertyOrDefault(properties, string(prefix + "rcvBufSize"), DefaultRcvBufSize);
-    fSndKernelSize = GetPropertyOrDefault(properties, string(prefix + "sndKernelSize"), fSndKernelSize);
+    fSndKernelSize = GetPropertyOrDefault(properties, string(prefix + "sndKernelSize"), DefaultSndKernelSize);
-    fRcvKernelSize = GetPropertyOrDefault(properties, string(prefix + "rcvKernelSize"), fRcvKernelSize);
+    fRcvKernelSize = GetPropertyOrDefault(properties, string(prefix + "rcvKernelSize"), DefaultRcvKernelSize);
-    fLinger = GetPropertyOrDefault(properties, string(prefix + "linger"), fLinger);
+    fLinger = GetPropertyOrDefault(properties, string(prefix + "linger"), DefaultLinger);
-    fRateLogging = GetPropertyOrDefault(properties, string(prefix + "rateLogging"), fRateLogging);
+    fRateLogging = GetPropertyOrDefault(properties, string(prefix + "rateLogging"), DefaultRateLogging);
-    fPortRangeMin = GetPropertyOrDefault(properties, string(prefix + "portRangeMin"), fPortRangeMin);
+    fPortRangeMin = GetPropertyOrDefault(properties, string(prefix + "portRangeMin"), DefaultPortRangeMin);
-    fPortRangeMax = GetPropertyOrDefault(properties, string(prefix + "portRangeMax"), fPortRangeMax);
+    fPortRangeMax = GetPropertyOrDefault(properties, string(prefix + "portRangeMax"), DefaultPortRangeMax);
-    fAutoBind = GetPropertyOrDefault(properties, string(prefix + "autoBind"), fAutoBind);
+    fAutoBind = GetPropertyOrDefault(properties, string(prefix + "autoBind"), DefaultAutoBind);
 }
 
 FairMQChannel::FairMQChannel(const FairMQChannel& chan)
@@ -125,10 +128,8 @@ FairMQChannel::FairMQChannel(const FairMQChannel& chan, const string& newName)
     , fPortRangeMin(chan.fPortRangeMin)
     , fPortRangeMax(chan.fPortRangeMax)
     , fAutoBind(chan.fAutoBind)
-    , fIsValid(false)
+    , fValid(false)
     , fMultipart(chan.fMultipart)
-    , fModified(chan.fModified)
-    , fReset(false)
 {}
 
 FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
@@ -137,372 +138,34 @@ FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
         return *this;
     }
 
-    {
+    fTransportFactory = nullptr;
-        // TODO: replace this with std::scoped_lock (c++17)
+    fTransportType = chan.fTransportType;
-        lock(fMtx, chan.fMtx);
+    fSocket = nullptr;
-        lock_guard<mutex> lock1(fMtx, adopt_lock);
+    fName = chan.fName;
-        lock_guard<mutex> lock2(chan.fMtx, adopt_lock);
+    fType = chan.fType;
-
+    fMethod = chan.fMethod;
-        fTransportFactory = nullptr;
+    fAddress = chan.fAddress;
-        fTransportType = chan.fTransportType;
+    fSndBufSize = chan.fSndBufSize;
-        fSocket = nullptr;
+    fRcvBufSize = chan.fRcvBufSize;
-        fName = chan.fName;
+    fSndKernelSize = chan.fSndKernelSize;
-        fType = chan.fType;
+    fRcvKernelSize = chan.fRcvKernelSize;
-        fMethod = chan.fMethod;
+    fLinger = chan.fLinger;
-        fAddress = chan.fAddress;
+    fRateLogging = chan.fRateLogging;
-        fSndBufSize = chan.fSndBufSize;
+    fPortRangeMin = chan.fPortRangeMin;
-        fRcvBufSize = chan.fRcvBufSize;
+    fPortRangeMax = chan.fPortRangeMax;
-        fSndKernelSize = chan.fSndKernelSize;
+    fAutoBind = chan.fAutoBind;
-        fRcvKernelSize = chan.fRcvKernelSize;
+    fValid = false;
-        fLinger = chan.fLinger;
+    fMultipart = chan.fMultipart;
-        fRateLogging = chan.fRateLogging;
-        fPortRangeMin = chan.fPortRangeMin;
-        fPortRangeMax = chan.fPortRangeMax;
-        fAutoBind = chan.fAutoBind;
-        fIsValid = false;
-        fMultipart = chan.fMultipart;
-        fModified = chan.fModified;
-        fReset = false;
-    }
 
     return *this;
 }
 
-FairMQSocket & FairMQChannel::GetSocket() const
-{
-    assert(fSocket);
-    return *fSocket;
-}
-
-string FairMQChannel::GetName() const
-{
-    lock_guard<mutex> lock(fMtx);
-    return fName;
-}
-
-string FairMQChannel::GetPrefix() const
-{
-    lock_guard<mutex> lock(fMtx);
-    string prefix = fName;
-    prefix = prefix.erase(fName.rfind('['));
-    return prefix;
-}
-
-string FairMQChannel::GetIndex() const
-{
-    lock_guard<mutex> lock(fMtx);
-    string indexStr = fName;
-    indexStr.erase(indexStr.rfind(']'));
-    indexStr.erase(0, indexStr.rfind('[') + 1);
-    return indexStr;
-}
-
-string FairMQChannel::GetType() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fType;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetType: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-string FairMQChannel::GetMethod() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fMethod;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetMethod: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-string FairMQChannel::GetAddress() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fAddress;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetAddress: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-string FairMQChannel::GetTransportName() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return TransportNames.at(fTransportType);
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetTransportName: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-Transport FairMQChannel::GetTransportType() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fTransportType;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetTransportType: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-
-int FairMQChannel::GetSndBufSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fSndBufSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetSndBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetRcvBufSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fRcvBufSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetRcvBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetSndKernelSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fSndKernelSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetSndKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetRcvKernelSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fRcvKernelSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetRcvKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetLinger() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fLinger;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetLinger: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetRateLogging() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fRateLogging;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetRateLogging: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetPortRangeMin() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fPortRangeMin;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetPortRangeMin: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetPortRangeMax() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fPortRangeMax;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetPortRangeMax: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-bool FairMQChannel::GetAutoBind() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fAutoBind;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetAutoBind: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateType(const string& type)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fType = type;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateType: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateMethod(const string& method)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fMethod = method;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateMethod: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateAddress(const string& address)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fAddress = address;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateAddress: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateTransport(const string& transport)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fTransportType = TransportTypes.at(transport);
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateTransport: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateSndBufSize(const int sndBufSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fSndBufSize = sndBufSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateSndBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateRcvBufSize(const int rcvBufSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fRcvBufSize = rcvBufSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateRcvBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateSndKernelSize(const int sndKernelSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fSndKernelSize = sndKernelSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateSndKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateRcvKernelSize(const int rcvKernelSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fRcvKernelSize = rcvKernelSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateRcvKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateLinger(const int duration)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fLinger = duration;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateLinger: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateRateLogging(const int rateLogging)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fRateLogging = rateLogging;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateRateLogging: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdatePortRangeMin(const int minPort)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fPortRangeMin = minPort;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdatePortRangeMin: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdatePortRangeMax(const int maxPort)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fPortRangeMax = maxPort;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdatePortRangeMax: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateAutoBind(const bool autobind)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fAutoBind = autobind;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateAutoBind: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-auto FairMQChannel::SetModified(const bool modified) -> void
-try {
-    lock_guard<mutex> lock(fMtx);
-    fModified = modified;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::SetModified: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateName(const string& name)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fName = name;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateName: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-bool FairMQChannel::IsValid() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fIsValid;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::IsValid: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
 bool FairMQChannel::Validate()
 try {
-    lock_guard<mutex> lock(fMtx);
     stringstream ss;
     ss << "Validating channel '" << fName << "'... ";
 
-    if (fIsValid) {
+    if (fValid) {
         ss << "ALREADY VALID";
         LOG(debug) << ss.str();
         return true;
@@ -535,7 +198,7 @@ try {
     } else {
         vector<string> endpoints;
         boost::algorithm::split(endpoints, fAddress, boost::algorithm::is_any_of(";"));
-        for (const auto endpoint : endpoints) {
+        for (const auto& endpoint : endpoints) {
             string address;
             if (endpoint[0] == '@' || endpoint[0] == '+' || endpoint[0] == '>') {
                 address = endpoint.substr(1);
@@ -637,7 +300,7 @@ try {
         throw ChannelConfigurationError(tools::ToString("invalid socket rate logging interval (cannot be negative): '", fRateLogging, "'"));
     }
 
-    fIsValid = true;
+    fValid = true;
     ss << "VALID";
     LOG(debug) << ss.str();
     return true;
@@ -648,8 +311,6 @@ try {
 
 void FairMQChannel::Init()
 {
-    lock_guard<mutex> lock(fMtx);
-
     fSocket = fTransportFactory->CreateSocket(fType, fName);
 
     // set linger duration (how long socket should wait for outstanding transfers before shutdown)
@@ -670,19 +331,22 @@ void FairMQChannel::Init()
 
 bool FairMQChannel::ConnectEndpoint(const string& endpoint)
 {
-    lock_guard<mutex> lock(fMtx);
-
     return fSocket->Connect(endpoint);
 }
 
 bool FairMQChannel::BindEndpoint(string& endpoint)
 {
-    lock_guard<mutex> lock(fMtx);
-
     // try to bind to the configured port. If it fails, try random one (if AutoBind is on).
     if (fSocket->Bind(endpoint)) {
         return true;
     } else {
+        // auto-bind only implemented for TCP
+        size_t protocolPos = endpoint.find(':');
+        string protocol = endpoint.substr(0, protocolPos);
+        if (protocol != "tcp") {
+            return false;
+        }
+
         if (fAutoBind) {
             // number of attempts when choosing a random port
             int numAttempts = 0;
@@ -712,10 +376,3 @@ bool FairMQChannel::BindEndpoint(string& endpoint)
     }
 
 }
-
-void FairMQChannel::ResetChannel()
-{
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    // TODO: implement channel resetting
-}

fairmq/FairMQChannel.h

@@ -13,7 +13,6 @@
 #include <FairMQUnmanagedRegion.h>
 #include <FairMQSocket.h>
 #include <fairmq/Transports.h>
-#include <FairMQLogger.h>
 #include <FairMQParts.h>
 #include <fairmq/Properties.h>
 #include <FairMQMessage.h>
@@ -24,9 +23,14 @@
 #include <mutex>
 #include <stdexcept>
 #include <utility> // std::move
-#include <cstddef> // size_t
 #include <cstdint> // int64_t
 
+/**
+ * @class FairMQChannel FairMQChannel.h <FairMQChannel.h>
+ * @brief Wrapper class for FairMQSocket and related methods
+ *
+ * The class is not thread-safe.
+ */
 class FairMQChannel
 {
     friend class FairMQDevice;
@@ -68,23 +72,20 @@ class FairMQChannel
     FairMQChannel(const FairMQChannel&, const std::string& name);
 
     /// Move constructor
-    FairMQChannel(FairMQChannel&&) = delete;
+    // FairMQChannel(FairMQChannel&&) = delete;
 
     /// Assignment operator
     FairMQChannel& operator=(const FairMQChannel&);
 
     /// Move assignment operator
-    FairMQChannel& operator=(FairMQChannel&&) = delete;
+    // FairMQChannel& operator=(FairMQChannel&&) = delete;
 
     /// Destructor
-    virtual ~FairMQChannel()
+    virtual ~FairMQChannel() { /* LOG(warn) << "Destroying channel '" << fName << "'"; */ }
-    {
-        // LOG(debug) << "Destroying channel " << fName;
-    }
 
     struct ChannelConfigurationError : std::runtime_error { using std::runtime_error::runtime_error; };
 
-    FairMQSocket& GetSocket() const;
+    FairMQSocket& GetSocket() const { assert(fSocket); return *fSocket; }
 
     bool Bind(const std::string& address)
     {
@@ -102,139 +103,142 @@ class FairMQChannel
 
     /// Get channel name
     /// @return Returns full channel name (e.g. "data[0]")
-    std::string GetChannelName() const __attribute__((deprecated("Use GetName()"))) { return GetName(); }
+    std::string GetName() const { return fName; }
-    std::string GetName() const ;
 
     /// Get channel prefix
     /// @return Returns channel prefix (e.g. "data" in "data[0]")
-    std::string GetChannelPrefix() const  __attribute__((deprecated("Use GetPrefix()"))) { return GetPrefix(); }
+    std::string GetPrefix() const
-    std::string GetPrefix() const;
+    {
+        std::string prefix = fName;
+        prefix = prefix.erase(fName.rfind('['));
+        return prefix;
+    }
 
     /// Get channel index
     /// @return Returns channel index (e.g. 0 in "data[0]")
-    std::string GetChannelIndex() const __attribute__((deprecated("Use GetIndex()"))) { return GetIndex(); }
+    std::string GetIndex() const
-    std::string GetIndex() const;
+    {
+        std::string indexStr = fName;
+        indexStr.erase(indexStr.rfind(']'));
+        indexStr.erase(0, indexStr.rfind('[') + 1);
+        return indexStr;
+    }
 
     /// Get socket type
     /// @return Returns socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
-    std::string GetType() const;
+    std::string GetType() const { return fType; }
 
     /// Get socket method
     /// @return Returns socket method (bind/connect)
-    std::string GetMethod() const;
+    std::string GetMethod() const { return fMethod; }
 
     /// Get socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
     /// @return Returns socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
-    std::string GetAddress() const;
+    std::string GetAddress() const { return fAddress; }
 
     /// Get channel transport name ("default", "zeromq" or "shmem")
     /// @return Returns channel transport name (e.g. "default", "zeromq" or "shmem")
-    std::string GetTransportName() const;
+    std::string GetTransportName() const { return fair::mq::TransportName(fTransportType); }
 
     /// Get channel transport type
     /// @return Returns channel transport type
-    fair::mq::Transport GetTransportType() const;
+    fair::mq::Transport GetTransportType() const { return fTransportType; }
 
     /// Get socket send buffer size (in number of messages)
     /// @return Returns socket send buffer size (in number of messages)
-    int GetSndBufSize() const;
+    int GetSndBufSize() const { return fSndBufSize; }
 
     /// Get socket receive buffer size (in number of messages)
     /// @return Returns socket receive buffer size (in number of messages)
-    int GetRcvBufSize() const;
+    int GetRcvBufSize() const { return fRcvBufSize; }
 
     /// Get socket kernel transmit send buffer size (in bytes)
     /// @return Returns socket kernel transmit send buffer size (in bytes)
-    int GetSndKernelSize() const;
+    int GetSndKernelSize() const { return fSndKernelSize; }
 
     /// Get socket kernel transmit receive buffer size (in bytes)
     /// @return Returns socket kernel transmit receive buffer size (in bytes)
-    int GetRcvKernelSize() const;
+    int GetRcvKernelSize() const { return fRcvKernelSize; }
 
     /// Get linger duration (in milliseconds)
     /// @return Returns linger duration (in milliseconds)
-    int GetLinger() const;
+    int GetLinger() const { return fLinger; }
 
     /// Get socket rate logging interval (in seconds)
     /// @return Returns socket rate logging interval (in seconds)
-    int GetRateLogging() const;
+    int GetRateLogging() const { return fRateLogging; }
 
     /// Get start of the port range for automatic binding
     /// @return start of the port range
-    int GetPortRangeMin() const;
+    int GetPortRangeMin() const { return fPortRangeMin; }
 
     /// Get end of the port range for automatic binding
     /// @return end of the port range
-    int GetPortRangeMax() const;
+    int GetPortRangeMax() const { return fPortRangeMax; }
 
     /// Set automatic binding (pick random port if bind fails)
     /// @return true/false, true if automatic binding is enabled
-    bool GetAutoBind() const;
+    bool GetAutoBind() const { return fAutoBind; }
-
-    /// Set socket type
-    /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
-    void UpdateType(const std::string& type);
-
-    /// Set socket method
-    /// @param method Socket method (bind/connect)
-    void UpdateMethod(const std::string& method);
-
-    /// Set socket address
-    /// @param Socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
-    void UpdateAddress(const std::string& address);
-
-    /// Set channel transport
-    /// @param transport transport string ("default", "zeromq" or "shmem")
-    void UpdateTransport(const std::string& transport);
-
-    /// Set socket send buffer size
-    /// @param sndBufSize Socket send buffer size (in number of messages)
-    void UpdateSndBufSize(const int sndBufSize);
-
-    /// Set socket receive buffer size
-    /// @param rcvBufSize Socket receive buffer size (in number of messages)
-    void UpdateRcvBufSize(const int rcvBufSize);
-
-    /// Set socket kernel transmit send buffer size (in bytes)
-    /// @param sndKernelSize Socket send buffer size (in bytes)
-    void UpdateSndKernelSize(const int sndKernelSize);
-
-    /// Set socket kernel transmit receive buffer size (in bytes)
-    /// @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) __attribute__((deprecated("Use UpdateName()"))) { UpdateName(name); }
+    void UpdateName(const std::string& name) { fName = name; Invalidate(); }
-    void UpdateName(const std::string& name);
+
+    /// Set socket type
+    /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
+    void UpdateType(const std::string& type) { fType = type; Invalidate(); }
+
+    /// Set socket method
+    /// @param method Socket method (bind/connect)
+    void UpdateMethod(const std::string& method) { fMethod = method; Invalidate(); }
+
+    /// Set socket address
+    /// @param Socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
+    void UpdateAddress(const std::string& address) { fAddress = address; Invalidate(); }
+
+    /// Set channel transport
+    /// @param transport transport string ("default", "zeromq" or "shmem")
+    void UpdateTransport(const std::string& transport) { fTransportType = fair::mq::TransportType(transport); Invalidate(); }
+
+    /// Set socket send buffer size
+    /// @param sndBufSize Socket send buffer size (in number of messages)
+    void UpdateSndBufSize(const int sndBufSize) { fSndBufSize = sndBufSize; Invalidate(); }
+
+    /// Set socket receive buffer size
+    /// @param rcvBufSize Socket receive buffer size (in number of messages)
+    void UpdateRcvBufSize(const int rcvBufSize) { fRcvBufSize = rcvBufSize; Invalidate(); }
+
+    /// Set socket kernel transmit send buffer size (in bytes)
+    /// @param sndKernelSize Socket send buffer size (in bytes)
+    void UpdateSndKernelSize(const int sndKernelSize) { fSndKernelSize = sndKernelSize; Invalidate(); }
+
+    /// Set socket kernel transmit receive buffer size (in bytes)
+    /// @param rcvKernelSize Socket receive buffer size (in bytes)
+    void UpdateRcvKernelSize(const int rcvKernelSize) { fRcvKernelSize = rcvKernelSize; Invalidate(); }
+
+    /// Set linger duration (in milliseconds)
+    /// @param duration linger duration (in milliseconds)
+    void UpdateLinger(const int duration) { fLinger = duration; Invalidate(); }
+
+    /// Set socket rate logging interval (in seconds)
+    /// @param rateLogging Socket rate logging interval (in seconds)
+    void UpdateRateLogging(const int rateLogging) { fRateLogging = rateLogging; Invalidate(); }
+
+    /// Set start of the port range for automatic binding
+    /// @param minPort start of the port range
+    void UpdatePortRangeMin(const int minPort) { fPortRangeMin = minPort; Invalidate(); }
+
+    /// Set end of the port range for automatic binding
+    /// @param maxPort end of the port range
+    void UpdatePortRangeMax(const int maxPort) { fPortRangeMax = maxPort; Invalidate(); }
+
+    /// Set automatic binding (pick random port if bind fails)
+    /// @param autobind true/false, true to enable automatic binding
+    void UpdateAutoBind(const bool autobind) { fAutoBind = autobind; Invalidate(); }
 
     /// 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.
-    bool IsValid() const;
+    bool IsValid() const { return fValid; }
-
-    /// Validates channel configuration
-    /// @return true if channel settings are valid, false otherwise.
-    bool ValidateChannel() __attribute__((deprecated("Use Validate()"))) { return Validate(); }
 
     /// Validates channel configuration
     /// @return true if channel settings are valid, false otherwise.
@@ -246,14 +250,14 @@ class FairMQChannel
 
     bool BindEndpoint(std::string& endpoint);
 
-    /// Resets the channel (requires validation to be used again).
+    /// invalidates the channel (requires validation to be used again).
-    void ResetChannel();
+    void Invalidate() { fValid = false; }
 
     /// Sends a message to the socket queue.
     /// @param msg Constant reference of unique_ptr to a FairMQMessage
     /// @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.
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
-    int Send(FairMQMessagePtr& msg, int sndTimeoutInMs = -1)
+    int64_t Send(FairMQMessagePtr& msg, int sndTimeoutInMs = -1)
     {
         CheckSendCompatibility(msg);
         return fSocket->Send(msg, sndTimeoutInMs);
@@ -262,8 +266,8 @@ class FairMQChannel
     /// Receives a message from the socket queue.
     /// @param msg Constant reference of unique_ptr to a FairMQMessage
     /// @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.
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
-    int Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs = -1)
+    int64_t Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs = -1)
     {
         CheckReceiveCompatibility(msg);
         return fSocket->Receive(msg, rcvTimeoutInMs);
@@ -272,7 +276,7 @@ class FairMQChannel
     /// Send a vector of messages
     /// @param msgVec message vector 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.
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
     int64_t Send(std::vector<FairMQMessagePtr>& msgVec, int sndTimeoutInMs = -1)
     {
         CheckSendCompatibility(msgVec);
@@ -282,7 +286,7 @@ class FairMQChannel
     /// Receive a vector of messages
     /// @param msgVec message vector 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.
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
     int64_t Receive(std::vector<FairMQMessagePtr>& msgVec, int rcvTimeoutInMs = -1)
     {
         CheckReceiveCompatibility(msgVec);
@@ -292,7 +296,7 @@ class FairMQChannel
     /// 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.
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
     int64_t Send(FairMQParts& parts, int sndTimeoutInMs = -1)
     {
         return Send(parts.fParts, sndTimeoutInMs);
@@ -301,7 +305,7 @@ class FairMQChannel
     /// 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.
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
     int64_t Receive(FairMQParts& parts, int rcvTimeoutInMs = -1)
     {
         return Receive(parts.fParts, rcvTimeoutInMs);
@@ -312,10 +316,7 @@ class FairMQChannel
     unsigned long GetMessagesTx() const { return fSocket->GetMessagesTx(); }
     unsigned long GetMessagesRx() const { return fSocket->GetMessagesRx(); }
 
-    auto Transport() -> FairMQTransportFactory*
+    auto Transport() -> FairMQTransportFactory* { return fTransportFactory.get(); };
-    {
-        return fTransportFactory.get();
-    };
 
     template<typename... Args>
     FairMQMessagePtr NewMessage(Args&&... args)
@@ -376,13 +377,9 @@ class FairMQChannel
     int fPortRangeMax;
     bool fAutoBind;
 
-    bool fIsValid;
+    bool fValid;
 
     bool fMultipart;
-    bool fModified;
-    bool fReset;
-
-    mutable std::mutex fMtx;
 
     void CheckSendCompatibility(FairMQMessagePtr& msg)
     {
@@ -439,8 +436,6 @@ class FairMQChannel
         fTransportFactory = factory;
         fTransportType = factory->GetType();
     }
-
-    auto SetModified(const bool modified) -> void;
 };
 
 #endif /* FAIRMQCHANNEL_H_ */

fairmq/FairMQDevice.cxx

@@ -24,34 +24,6 @@
 using namespace std;
 using namespace fair::mq;
 
-static map<Transition, State> backwardsCompatibilityWaitForEndOfStateHelper =
-{
-    { Transition::InitDevice,   State::InitializingDevice },
-    { Transition::CompleteInit, State::Initialized },
-    { Transition::Bind,         State::Bound },
-    { Transition::Connect,      State::DeviceReady },
-    { Transition::InitTask,     State::Ready },
-    { Transition::Run,          State::Ready },
-    { Transition::Stop,         State::Ready },
-    { Transition::ResetTask,    State::DeviceReady },
-    { Transition::ResetDevice,  State::Idle }
-};
-
-static map<int, Transition> backwardsCompatibilityChangeStateHelper =
-{
-    { FairMQDevice::Event::INIT_DEVICE,           Transition::InitDevice },
-    { FairMQDevice::Event::internal_DEVICE_READY, Transition::Auto },
-    { FairMQDevice::Event::INIT_TASK,             Transition::InitTask },
-    { FairMQDevice::Event::internal_READY,        Transition::Auto },
-    { FairMQDevice::Event::RUN,                   Transition::Run },
-    { FairMQDevice::Event::STOP,                  Transition::Stop },
-    { FairMQDevice::Event::RESET_TASK,            Transition::ResetTask },
-    { FairMQDevice::Event::RESET_DEVICE,          Transition::ResetDevice },
-    { FairMQDevice::Event::internal_IDLE,         Transition::Auto },
-    { FairMQDevice::Event::END,                   Transition::End },
-    { FairMQDevice::Event::ERROR_FOUND,           Transition::ErrorFound }
-};
-
 constexpr const char* FairMQDevice::DefaultId;
 constexpr int FairMQDevice::DefaultIOThreads;
 constexpr const char* FairMQDevice::DefaultTransportName;
@@ -103,7 +75,7 @@ FairMQDevice::FairMQDevice(ProgOptions* config, const tools::Version version)
     : fTransportFactory(nullptr)
     , fTransports()
     , fChannels()
-    , fInternalConfig(config ? nullptr : tools::make_unique<ProgOptions>())
+    , fInternalConfig(config ? nullptr : make_unique<ProgOptions>())
     , fConfig(config ? config : fInternalConfig.get())
     , fId(DefaultId)
     , fDefaultTransportType(DefaultTransportType)
@@ -244,16 +216,6 @@ void FairMQDevice::TransitionTo(const fair::mq::State s)
     }
 }
 
-bool FairMQDevice::ChangeState(const int transition)
-{
-    return ChangeState(backwardsCompatibilityChangeStateHelper.at(transition));
-}
-
-void FairMQDevice::WaitForEndOfState(Transition transition)
-{
-    WaitForState(backwardsCompatibilityWaitForEndOfStateHelper.at(transition));
-}
-
 void FairMQDevice::InitWrapper()
 {
     // run initialization once CompleteInit transition is requested
@@ -390,7 +352,6 @@ void FairMQDevice::AttachChannels(vector<FairMQChannel*>& chans)
         if ((*itr)->Validate()) {
             (*itr)->Init();
             if (AttachChannel(**itr)) {
-                (*itr)->SetModified(false);
                 // remove the channel from the uninitialized container
                 itr = chans.erase(itr);
             } else {
@@ -525,7 +486,6 @@ void FairMQDevice::RunWrapper()
         }
 
         PostRun();
-
     } catch (const out_of_range& oor) {
         LOG(error) << "out of range: " << oor.what();
         LOG(error) << "incorrect/incomplete channel configuration?";
@@ -543,17 +503,12 @@ void FairMQDevice::HandleSingleChannelInput()
 {
     bool proceed = true;
 
-    if (fMsgInputs.size() > 0)
+    if (fMsgInputs.size() > 0) {
-    {
+        while (!NewStatePending() && proceed) {
-        while (!NewStatePending() && proceed)
-        {
             proceed = HandleMsgInput(fInputChannelKeys.at(0), fMsgInputs.begin()->second, 0);
         }
-    }
+    } else if (fMultipartInputs.size() > 0) {
-    else if (fMultipartInputs.size() > 0)
+        while (!NewStatePending() && proceed) {
-    {
-        while (!NewStatePending() && proceed)
-        {
             proceed = HandleMultipartInput(fInputChannelKeys.at(0), fMultipartInputs.begin()->second, 0);
         }
     }
@@ -563,75 +518,55 @@ void FairMQDevice::HandleMultipleChannelInput()
 {
     // check if more than one transport is used
     fMultitransportInputs.clear();
-    for (const auto& k : fInputChannelKeys)
+    for (const auto& k : fInputChannelKeys) {
-    {
         fair::mq::Transport t = fChannels.at(k).at(0).fTransportType;
-        if (fMultitransportInputs.find(t) == fMultitransportInputs.end())
+        if (fMultitransportInputs.find(t) == fMultitransportInputs.end()) {
-        {
             fMultitransportInputs.insert(pair<fair::mq::Transport, vector<string>>(t, vector<string>()));
             fMultitransportInputs.at(t).push_back(k);
-        }
+        } else {
-        else
-        {
             fMultitransportInputs.at(t).push_back(k);
         }
     }
 
-    for (const auto& mi : fMsgInputs)
+    for (const auto& mi : fMsgInputs) {
-    {
+        for (auto& i : fChannels.at(mi.first)) {
-        for (auto& i : fChannels.at(mi.first))
-        {
             i.fMultipart = false;
         }
     }
 
-    for (const auto& mi : fMultipartInputs)
+    for (const auto& mi : fMultipartInputs) {
-    {
+        for (auto& i : fChannels.at(mi.first)) {
-        for (auto& i : fChannels.at(mi.first))
-        {
             i.fMultipart = true;
         }
     }
 
     // if more than one transport is used, handle poll of each in a separate thread
-    if (fMultitransportInputs.size() > 1)
+    if (fMultitransportInputs.size() > 1) {
-    {
         HandleMultipleTransportInput();
-    }
+    } else { // otherwise poll directly
-    else // otherwise poll directly
-    {
         bool proceed = true;
 
         FairMQPollerPtr poller(fChannels.at(fInputChannelKeys.at(0)).at(0).fTransportFactory->CreatePoller(fChannels, fInputChannelKeys));
 
-        while (!NewStatePending() && proceed)
+        while (!NewStatePending() && proceed) {
-        {
             poller->Poll(200);
 
             // check which inputs are ready and call their data handlers if they are.
-            for (const auto& ch : fInputChannelKeys)
+            for (const auto& ch : fInputChannelKeys) {
-            {
+                for (unsigned int i = 0; i < fChannels.at(ch).size(); ++i) {
-                for (unsigned int i = 0; i < fChannels.at(ch).size(); ++i)
+                    if (poller->CheckInput(ch, i)) {
-                {
+                        if (fChannels.at(ch).at(i).fMultipart) {
-                    if (poller->CheckInput(ch, i))
-                    {
-                        if (fChannels.at(ch).at(i).fMultipart)
-                        {
                             proceed = HandleMultipartInput(ch, fMultipartInputs.at(ch), i);
-                        }
+                        } else {
-                        else
-                        {
                             proceed = HandleMsgInput(ch, fMsgInputs.at(ch), i);
                         }
 
-                        if (!proceed)
+                        if (!proceed) {
-                        {
                             break;
                         }
                     }
                 }
-                if (!proceed)
+                if (!proceed) {
-                {
                     break;
                 }
             }
@@ -645,64 +580,49 @@ void FairMQDevice::HandleMultipleTransportInput()
 
     fMultitransportProceed = true;
 
-    for (const auto& i : fMultitransportInputs)
+    for (const auto& i : fMultitransportInputs) {
-    {
         threads.emplace_back(thread(&FairMQDevice::PollForTransport, this, fTransports.at(i.first).get(), i.second));
     }
 
-    for (thread& t : threads)
+    for (thread& t : threads) {
-    {
         t.join();
     }
 }
 
 void FairMQDevice::PollForTransport(const FairMQTransportFactory* factory, const vector<string>& channelKeys)
 {
-    try
+    try {
-    {
         FairMQPollerPtr poller(factory->CreatePoller(fChannels, channelKeys));
 
-        while (!NewStatePending() && fMultitransportProceed)
+        while (!NewStatePending() && fMultitransportProceed) {
-        {
             poller->Poll(500);
 
-            for (const auto& ch : channelKeys)
+            for (const auto& ch : channelKeys) {
-            {
+                for (unsigned int i = 0; i < fChannels.at(ch).size(); ++i) {
-                for (unsigned int i = 0; i < fChannels.at(ch).size(); ++i)
+                    if (poller->CheckInput(ch, i)) {
-                {
-                    if (poller->CheckInput(ch, i))
-                    {
                         lock_guard<mutex> lock(fMultitransportMutex);
 
-                        if (!fMultitransportProceed)
+                        if (!fMultitransportProceed) {
-                        {
                             break;
                         }
 
-                        if (fChannels.at(ch).at(i).fMultipart)
+                        if (fChannels.at(ch).at(i).fMultipart) {
-                        {
                             fMultitransportProceed = HandleMultipartInput(ch, fMultipartInputs.at(ch), i);
-                        }
+                        } else {
-                        else
-                        {
                             fMultitransportProceed = HandleMsgInput(ch, fMsgInputs.at(ch), i);
                         }
 
-                        if (!fMultitransportProceed)
+                        if (!fMultitransportProceed) {
-                        {
                             break;
                         }
                     }
                 }
-                if (!fMultitransportProceed)
+                if (!fMultitransportProceed) {
-                {
                     break;
                 }
             }
         }
-    }
+    } catch (exception& e) {
-    catch (exception& e)
-    {
         LOG(error) << "FairMQDevice::PollForTransport() failed: " << e.what() << ", going to ERROR state.";
         throw runtime_error(tools::ToString("FairMQDevice::PollForTransport() failed: ", e.what(), ", going to ERROR state."));
     }
@@ -712,12 +632,9 @@ bool FairMQDevice::HandleMsgInput(const string& chName, const InputMsgCallback&
 {
     unique_ptr<FairMQMessage> input(fChannels.at(chName).at(i).fTransportFactory->CreateMessage());
 
-    if (Receive(input, chName, i) >= 0)
+    if (Receive(input, chName, i) >= 0) {
-    {
         return callback(input, i);
-    }
+    } else {
-    else
-    {
         return false;
     }
 }
@@ -726,12 +643,9 @@ bool FairMQDevice::HandleMultipartInput(const string& chName, const InputMultipa
 {
     FairMQParts input;
 
-    if (Receive(input, chName, i) >= 0)
+    if (Receive(input, chName, i) >= 0) {
-    {
+        return callback(input, i);
-        return callback(input, 0);
+    } else {
-    }
-    else
-    {
         return false;
     }
 }

fairmq/FairMQDevice.h

@@ -9,24 +9,23 @@
 #ifndef FAIRMQDEVICE_H_
 #define FAIRMQDEVICE_H_
 
-#include <StateMachine.h>
-#include <FairMQTransportFactory.h>
-#include <fairmq/Transports.h>
-#include <fairmq/StateQueue.h>
-
 #include <FairMQChannel.h>
+#include <FairMQLogger.h>
 #include <FairMQMessage.h>
 #include <FairMQParts.h>
+#include <FairMQTransportFactory.h>
 #include <FairMQUnmanagedRegion.h>
-#include <FairMQLogger.h>
 #include <fairmq/ProgOptions.h>
+#include <fairmq/StateMachine.h>
+#include <fairmq/StateQueue.h>
+#include <fairmq/Transports.h>
+#include <fairmq/tools/Version.h>
 
 #include <vector>
 #include <memory> // unique_ptr
 #include <algorithm> // find
 #include <string>
 #include <chrono>
-#include <iostream>
 #include <unordered_map>
 #include <functional>
 #include <stdexcept>
@@ -35,58 +34,21 @@
 #include <cstddef>
 #include <utility> // pair
 
-#include <fairmq/tools/Version.h>
-
 using FairMQChannelMap = std::unordered_map<std::string, std::vector<FairMQChannel>>;
 
 using InputMsgCallback = std::function<bool(FairMQMessagePtr&, int)>;
 using InputMultipartCallback = std::function<bool(FairMQParts&, int)>;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 struct OngoingTransition : std::runtime_error { using std::runtime_error::runtime_error; };
 }
-}
 
 class FairMQDevice
 {
     friend class FairMQChannel;
 
   public:
-    // backwards-compatibility enum for old state machine interface, todo: delete this
-    enum Event
-    {
-        INIT_DEVICE,
-        internal_DEVICE_READY,
-        INIT_TASK,
-        internal_READY,
-        RUN,
-        STOP,
-        RESET_TASK,
-        RESET_DEVICE,
-        internal_IDLE,
-        END,
-        ERROR_FOUND
-    };
-
-    // backwards-compatibility enum for old state machine interface, todo: delete this
-    enum State
-    {
-        OK,
-        Error,
-        IDLE,
-        INITIALIZING_DEVICE,
-        DEVICE_READY,
-        INITIALIZING_TASK,
-        READY,
-        RUNNING,
-        RESETTING_TASK,
-        RESETTING_DEVICE,
-        EXITING
-    };
-
     /// Default constructor
     FairMQDevice();
     /// Constructor with external fair::mq::ProgOptions
@@ -129,8 +91,8 @@ class FairMQDevice
     /// @param chan channel name
     /// @param i channel index
     /// @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.
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
-    int Send(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
+    int64_t Send(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
     {
         return GetChannel(channel, index).Send(msg, sndTimeoutInMs);
     }
@@ -140,8 +102,8 @@ class FairMQDevice
     /// @param chan channel name
     /// @param i channel index
     /// @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.
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
-    int Receive(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
+    int64_t Receive(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
     {
         return GetChannel(channel, index).Receive(msg, rcvTimeoutInMs);
     }
@@ -151,7 +113,7 @@ class FairMQDevice
     /// @param chan channel name
     /// @param i channel index
     /// @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.
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
     int64_t Send(FairMQParts& parts, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
     {
         return GetChannel(channel, index).Send(parts.fParts, sndTimeoutInMs);
@@ -162,7 +124,7 @@ class FairMQDevice
     /// @param chan channel name
     /// @param i channel index
     /// @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.
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
     int64_t Receive(FairMQParts& parts, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
     {
         return GetChannel(channel, index).Receive(parts.fParts, rcvTimeoutInMs);
@@ -363,10 +325,10 @@ class FairMQDevice
     void PrintRegisteredChannels()
     {
         if (fChannelRegistry.size() < 1) {
-            std::cout << "no channels registered." << std::endl;
+            LOGV(info, verylow) << "no channels registered.";
         } else {
             for (const auto& c : fChannelRegistry) {
-                std::cout << c.first << ":" << c.second.first << ":" << c.second.second << std::endl;
+                LOGV(info, verylow) << c.first << ":" << c.second.first << ":" << c.second.second;
             }
         }
     }
@@ -450,8 +412,6 @@ class FairMQDevice
     /// Called in the RUNNING state once after executing the Run()/ConditionalRun() method
     virtual void PostRun() {}
 
-    virtual void Pause() __attribute__((deprecated("PAUSE state is removed. This method is never called. To pause Run, go to READY with STOP transition and back to RUNNING with RUN to resume."))) {}
-
     /// Resets the user task (to be overloaded in child classes)
     virtual void ResetTask() {}
 
@@ -459,36 +419,64 @@ class FairMQDevice
     virtual void Reset() {}
 
   public:
+    /// @brief Request a device state transition
+    /// @param transition state transition
+    ///
+    /// The state transition may not happen immediately, but when the current state evaluates the
+    /// pending transition event and terminates. In other words, the device states are scheduled cooperatively.
     bool ChangeState(const fair::mq::Transition transition) { return fStateMachine.ChangeState(transition); }
+    /// @brief Request a device state transition
+    /// @param transition state transition
+    ///
+    /// The state transition may not happen immediately, but when the current state evaluates the
+    /// pending transition event and terminates. In other words, the device states are scheduled cooperatively.
     bool ChangeState(const std::string& transition) { return fStateMachine.ChangeState(fair::mq::GetTransition(transition)); }
 
-    bool ChangeState(const int transition) __attribute__((deprecated("Use ChangeState(const fair::mq::Transition transition).")));
+    /// @brief waits for the next state (any) to occur
-
-    void WaitForEndOfState(const fair::mq::Transition transition) __attribute__((deprecated("Use WaitForState(fair::mq::State expectedState).")));
-    void WaitForEndOfState(const std::string& transition) __attribute__((deprecated("Use WaitForState(fair::mq::State expectedState)."))) { WaitForState(transition); }
-
     fair::mq::State WaitForNextState() { return fStateQueue.WaitForNext(); }
+    /// @brief waits for the specified state to occur
+    /// @param state state to wait for
     void WaitForState(fair::mq::State state) { fStateQueue.WaitForState(state); }
+    /// @brief waits for the specified state to occur
+    /// @param state state to wait for
     void WaitForState(const std::string& state) { WaitForState(fair::mq::GetState(state)); }
 
     void TransitionTo(const fair::mq::State state);
 
+    /// @brief Subscribe with a callback to state changes
+    /// @param key id to identify your subscription
+    /// @param callback callback (called with the new state as the parameter)
+    ///
+    /// The callback is called at the beginning of a new state.
+    /// The callback is called from the thread the state is running in.
     void SubscribeToStateChange(const std::string& key, std::function<void(const fair::mq::State)> callback) { fStateMachine.SubscribeToStateChange(key, callback); }
+    /// @brief Unsubscribe from state changes
+    /// @param key id (that was used when subscribing)
     void UnsubscribeFromStateChange(const std::string& key) { fStateMachine.UnsubscribeFromStateChange(key); }
 
+    /// @brief Subscribe with a callback to incoming state transitions
+    /// @param key id to identify your subscription
+    /// @param callback callback (called with the incoming transition as the parameter)
+    /// The callback is called when new transition is initiated.
+    /// The callback is called from the thread that initiates the transition (via ChangeState).
     void SubscribeToNewTransition(const std::string& key, std::function<void(const fair::mq::Transition)> callback) { fStateMachine.SubscribeToNewTransition(key, callback); }
+    /// @brief Unsubscribe from state transitions
+    /// @param key id (that was used when subscribing)
     void UnsubscribeFromNewTransition(const std::string& key) { fStateMachine.UnsubscribeFromNewTransition(key); }
 
-    bool CheckCurrentState(const int /* state */) const __attribute__((deprecated("Use NewStatePending()."))) { return !fStateMachine.NewStatePending(); }
+    /// @brief Returns true if a new state has been requested, signaling the current handler to stop.
-    bool CheckCurrentState(const std::string& /* state */) const __attribute__((deprecated("Use NewStatePending()."))) { return !fStateMachine.NewStatePending(); }
-
-    /// Returns true is a new state has been requested, signaling the current handler to stop.
     bool NewStatePending() const { return fStateMachine.NewStatePending(); }
 
+    /// @brief Returns the current state
     fair::mq::State GetCurrentState() const { return fStateMachine.GetCurrentState(); }
+    /// @brief Returns the name of the current state as a string
     std::string GetCurrentStateName() const { return fStateMachine.GetCurrentStateName(); }
 
+    /// @brief Returns name of the given state as a string
+    /// @param state state
     static std::string GetStateName(const fair::mq::State state) { return fair::mq::GetStateName(state); }
+    /// @brief Returns name of the given transition as a string
+    /// @param transition transition
     static std::string GetTransitionName(const fair::mq::Transition transition) { return fair::mq::GetTransitionName(transition); }
 
     static constexpr const char* DefaultId = "";

fairmq/FairMQMessage.h

@@ -11,15 +11,14 @@
 
 #include <cstddef> // for size_t
 #include <memory> // unique_ptr
+#include <stdexcept>
 
 #include <fairmq/Transports.h>
 
 using fairmq_free_fn = void(void* data, void* hint);
 class FairMQTransportFactory;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 struct Alignment
@@ -28,8 +27,7 @@ struct Alignment
     explicit operator size_t() const { return alignment; }
 };
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 class FairMQMessage
 {
@@ -38,7 +36,9 @@ class FairMQMessage
     FairMQMessage(FairMQTransportFactory* factory) : fTransport(factory) {}
 
     virtual void Rebuild() = 0;
+    virtual void Rebuild(fair::mq::Alignment alignment) = 0;
     virtual void Rebuild(const size_t size) = 0;
+    virtual void Rebuild(const size_t size, fair::mq::Alignment alignment) = 0;
     virtual void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) = 0;
 
     virtual void* GetData() const = 0;
@@ -60,9 +60,7 @@ class FairMQMessage
 
 using FairMQMessagePtr = std::unique_ptr<FairMQMessage>;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 using Message = FairMQMessage;
@@ -70,7 +68,6 @@ using MessagePtr = FairMQMessagePtr;
 struct MessageError : std::runtime_error { using std::runtime_error::runtime_error; };
 struct MessageBadAlloc : std::runtime_error { using std::runtime_error::runtime_error; };
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIRMQMESSAGE_H_ */

fairmq/FairMQPoller.h

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -9,8 +9,9 @@
 #ifndef FAIRMQPOLLER_H_
 #define FAIRMQPOLLER_H_
 
-#include <string>
 #include <memory>
+#include <stdexcept>
+#include <string>
 
 class FairMQPoller
 {
@@ -26,16 +27,13 @@ class FairMQPoller
 
 using FairMQPollerPtr = std::unique_ptr<FairMQPoller>;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 using Poller = FairMQPoller;
 using PollerPtr = FairMQPollerPtr;
 struct PollerError : std::runtime_error { using std::runtime_error::runtime_error; };
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIRMQPOLLER_H_ */

fairmq/FairMQSocket.h

@@ -9,13 +9,29 @@
 #ifndef FAIRMQSOCKET_H_
 #define FAIRMQSOCKET_H_
 
+#include "FairMQMessage.h"
+
+#include <memory>
+#include <ostream>
+#include <stdexcept>
 #include <string>
 #include <vector>
-#include <memory>
 
-#include "FairMQMessage.h"
 class FairMQTransportFactory;
 
+namespace fair::mq
+{
+
+enum class TransferCode : int
+{
+    success = 0,
+    error = -1,
+    timeout = -2,
+    interrupted = -3
+};
+
+} // namespace fair::mq
+
 class FairMQSocket
 {
   public:
@@ -27,8 +43,8 @@ class FairMQSocket
     virtual bool Bind(const std::string& address) = 0;
     virtual bool Connect(const std::string& address) = 0;
 
-    virtual int Send(FairMQMessagePtr& msg, int timeout = -1) = 0;
+    virtual int64_t Send(FairMQMessagePtr& msg, int timeout = -1) = 0;
-    virtual int Receive(FairMQMessagePtr& msg, int timeout = -1) = 0;
+    virtual int64_t 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;
 
@@ -37,6 +53,10 @@ class FairMQSocket
     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;
 
+    /// If the backend supports it, fills the unsigned integer @a events with the ZMQ_EVENTS value
+    /// DISCLAIMER: this API is experimental and unsupported and might be dropped / refactored in
+    /// the future.
+    virtual void Events(uint32_t* events) = 0;
     virtual void SetLinger(const int value) = 0;
     virtual int GetLinger() const = 0;
     virtual void SetSndBufSize(const int value) = 0;
@@ -64,16 +84,13 @@ class FairMQSocket
 
 using FairMQSocketPtr = std::unique_ptr<FairMQSocket>;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 using Socket = FairMQSocket;
 using SocketPtr = FairMQSocketPtr;
 struct SocketError : std::runtime_error { using std::runtime_error::runtime_error; };
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIRMQSOCKET_H_ */

fairmq/FairMQTransportFactory.cxx

@@ -13,7 +13,10 @@
 #include <fairmq/ofi/TransportFactory.h>
 #endif
 #include <FairMQLogger.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Unique.h>
+#include <fairmq/tools/Strings.h>
+
+#include <fairlogger/Logger.h>
 
 #include <memory>
 #include <string>

fairmq/FairMQTransportFactory.h

@@ -9,7 +9,6 @@
 #ifndef FAIRMQTRANSPORTFACTORY_H_
 #define FAIRMQTRANSPORTFACTORY_H_
 
-#include <FairMQLogger.h>
 #include <FairMQMessage.h>
 #include <FairMQPoller.h>
 #include <FairMQSocket.h>
@@ -25,7 +24,7 @@
 #include <cstddef> // size_t
 
 class FairMQChannel;
-namespace fair { namespace mq { class ProgOptions; } }
+namespace fair::mq { class ProgOptions; }
 
 class FairMQTransportFactory
 {
@@ -172,15 +171,12 @@ class FairMQTransportFactory
     }
 };
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 using TransportFactory = FairMQTransportFactory;
 struct TransportFactoryError : std::runtime_error { using std::runtime_error::runtime_error; };
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIRMQTRANSPORTFACTORY_H_ */

fairmq/FairMQUnmanagedRegion.h

@@ -10,6 +10,7 @@
 #define FAIRMQUNMANAGEDREGION_H_
 
 #include <cstddef> // size_t
+#include <cstdint> // uint32_t
 #include <memory> // std::unique_ptr
 #include <functional> // std::function
 #include <ostream> // std::ostream
@@ -27,21 +28,24 @@ enum class FairMQRegionEvent : int
 struct FairMQRegionInfo
 {
     FairMQRegionInfo()
-        : id(0)
+        : managed(true)
+        , id(0)
         , ptr(nullptr)
         , size(0)
         , flags(0)
         , event(FairMQRegionEvent::created)
     {}
 
-    FairMQRegionInfo(uint64_t _id, void* _ptr, size_t _size, int64_t _flags, FairMQRegionEvent _event)
+    FairMQRegionInfo(bool _managed, uint64_t _id, void* _ptr, size_t _size, int64_t _flags, FairMQRegionEvent _event)
-        : id(_id)
+        : managed(_managed)
+        , id(_id)
         , ptr(_ptr)
         , size(_size)
         , flags(_flags)
-        , event (_event)
+        , event(_event)
     {}
 
+    bool managed;  // managed/unmanaged
     uint64_t id;   // id of the region
     void* ptr;     // pointer to the start of the region
     size_t size;   // region size
@@ -71,7 +75,9 @@ class FairMQUnmanagedRegion
 
     virtual void* GetData() const = 0;
     virtual size_t GetSize() const = 0;
-    virtual uint64_t GetId() const = 0;
+    virtual uint16_t GetId() const = 0;
+    virtual void SetLinger(uint32_t linger) = 0;
+    virtual uint32_t GetLinger() const = 0;
 
     FairMQTransportFactory* GetTransport() { return fTransport; }
     void SetTransport(FairMQTransportFactory* transport) { fTransport = transport; }
@@ -98,9 +104,7 @@ inline std::ostream& operator<<(std::ostream& os, const FairMQRegionEvent& event
     }
 }
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 using RegionCallback = FairMQRegionCallback;
@@ -112,7 +116,6 @@ using RegionBlock = FairMQRegionBlock;
 using UnmanagedRegion = FairMQUnmanagedRegion;
 using UnmanagedRegionPtr = FairMQUnmanagedRegionPtr;
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIRMQUNMANAGEDREGION_H_ */

fairmq/JSONParser.cxx

@@ -12,25 +12,25 @@
  * Created on May 14, 2015, 5:01 PM
  */
 
-#include <fairmq/PropertyOutput.h>
 #include "JSONParser.h"
-#include "FairMQLogger.h"
+#include "FairMQChannel.h"
-#include <fairmq/Tools.h>
+#include <fairmq/PropertyOutput.h>
+#include <fairmq/tools/Strings.h>
+
+#include <fairlogger/Logger.h>
 
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/any.hpp>
 
-#include <ios>
+#include <iomanip>
 
 using namespace std;
 using namespace fair::mq;
 using namespace fair::mq::tools;
 using namespace boost::property_tree;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 fair::mq::Properties PtreeParser(const ptree& pt, const string& id)
@@ -183,5 +183,4 @@ void SubChannelParser(const ptree& channelTree, fair::mq::Properties& properties
 }
 
 } // helper namespace
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair

fairmq/JSONParser.h

@@ -15,19 +15,13 @@
 #ifndef FAIR_MQ_JSONPARSER_H
 #define FAIR_MQ_JSONPARSER_H
 
-#include <string>
+#include <fairmq/Properties.h>
-#include <vector>
-#include <unordered_map>
-#include <exception>
-
 #include <boost/property_tree/ptree_fwd.hpp>
 
-#include "FairMQChannel.h"
+#include <stdexcept>
-#include <fairmq/Properties.h>
+#include <string>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 struct ParserError : std::runtime_error { using std::runtime_error::runtime_error; };
@@ -45,7 +39,6 @@ void SubChannelParser(const boost::property_tree::ptree& tree, fair::mq::Propert
 
 } // helper namespace
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair
 
 #endif /* FAIR_MQ_JSONPARSER_H */

fairmq/MemoryResourceTools.h

@@ -15,8 +15,8 @@
 #include <fairmq/FairMQTransportFactory.h>
 #include <fairmq/MemoryResources.h>
 
-namespace fair {
+namespace fair::mq
-namespace mq {
+{
 
 using BytePmrAllocator = pmr::polymorphic_allocator<fair::mq::byte>;
 
@@ -62,5 +62,4 @@ FairMQMessagePtr getMessage(ContainerT &&container_, FairMQMemoryResource *targe
     return message;
 }
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */

fairmq/MemoryResources.cxx

@@ -15,8 +15,7 @@
 #include <fairmq/FairMQTransportFactory.h>
 #include <fairmq/MemoryResources.h>
 
-void *fair::mq::ChannelResource::do_allocate(std::size_t bytes, std::size_t /*alignment*/)
+void *fair::mq::ChannelResource::do_allocate(std::size_t bytes, std::size_t alignment)
 {
-    return setMessage(factory->CreateMessage(bytes));
+    return setMessage(factory->CreateMessage(bytes, fair::mq::Alignment{alignment}));
 }
-

fairmq/MemoryResources.h

@@ -15,18 +15,19 @@
 #ifndef FAIR_MQ_MEMORY_RESOURCES_H
 #define FAIR_MQ_MEMORY_RESOURCES_H
 
-#include <fairmq/FairMQMessage.h>
+#include <FairMQMessage.h>
 class FairMQTransportFactory;
 
+#include <boost/container/container_fwd.hpp>
 #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 <stdexcept>
 #include <utility>
 
-namespace fair {
+namespace fair::mq
-namespace mq {
+{
 
 using byte = unsigned char;
 namespace pmr = boost::container::pmr;
@@ -106,7 +107,6 @@ class ChannelResource : public FairMQMemoryResource
     };
 };
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIR_MQ_MEMORY_RESOURCES_H */

fairmq/Plugin.h

@@ -9,7 +9,6 @@
 #ifndef FAIR_MQ_PLUGIN_H
 #define FAIR_MQ_PLUGIN_H
 
-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Version.h>
 #include <fairmq/PluginServices.h>
 
@@ -25,9 +24,7 @@
 #include <tuple>
 #include <utility>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 /**
@@ -134,13 +131,12 @@ class Plugin
     PluginServices* fPluginServices;
 }; /* class Plugin */
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #define REGISTER_FAIRMQ_PLUGIN(KLASS, NAME, VERSION, MAINTAINER, HOMEPAGE, PROGOPTIONS) \
 static auto Make_##NAME##_Plugin(fair::mq::PluginServices* pluginServices) -> std::unique_ptr<fair::mq::Plugin> \
 { \
-    return fair::mq::tools::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
+    return std::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
 } \
 BOOST_DLL_ALIAS(Make_##NAME##_Plugin, make_##NAME##_plugin) \
 BOOST_DLL_ALIAS(PROGOPTIONS, get_##NAME##_plugin_progoptions)

fairmq/PluginManager.h

@@ -11,7 +11,6 @@
 
 #include <fairmq/Plugin.h>
 #include <fairmq/PluginServices.h>
-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Strings.h>
 
 #define BOOST_FILESYSTEM_VERSION 3
@@ -31,9 +30,7 @@
 #include <vector>
 #include <utility> // forward
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 /**
@@ -80,7 +77,7 @@ class PluginManager
     auto ForEachPluginProgOptions(std::function<void (boost::program_options::options_description)> func) const -> void { for(const auto& pair : fPluginProgOptions) { func(pair.second); } }
 
     template<typename... Args>
-    auto EmplacePluginServices(Args&&... args) -> void { fPluginServices = fair::mq::tools::make_unique<PluginServices>(std::forward<Args>(args)...); }
+    auto EmplacePluginServices(Args&&... args) -> void { fPluginServices = std::make_unique<PluginServices>(std::forward<Args>(args)...); }
 
     auto WaitForPluginsToReleaseDeviceControl() -> void { fPluginServices->WaitForReleaseDeviceControl(); }
 
@@ -126,7 +123,6 @@ class PluginManager
     std::map<std::string, boost::program_options::options_description> fPluginProgOptions;
 }; /* class PluginManager */
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIR_MQ_PLUGINMANAGER_H */

fairmq/PluginServices.h

@@ -17,17 +17,16 @@
 #include <boost/optional.hpp>
 #include <boost/optional/optional_io.hpp>
 
+#include <condition_variable>
 #include <functional>
+#include <map>
+#include <mutex>
+#include <stdexcept>
 #include <string>
 #include <unordered_map>
-#include <mutex>
+#include <vector>
-#include <map>
-#include <condition_variable>
-#include <stdexcept>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 /**
@@ -280,7 +279,6 @@ class PluginServices
     std::condition_variable fReleaseDeviceControlCondition;
 }; /* class PluginServices */
 
-} /* namespace mq */
+} // namespace fair::mq
-} /* namespace fair */
 
 #endif /* FAIR_MQ_PLUGINSERVICES_H */

fairmq/ProgOptions.cxx

@@ -39,9 +39,7 @@ struct ValInfo
     string origin;
 };
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 ValInfo ConvertVarValToValInfo(const po::variable_value& v)
@@ -79,7 +77,7 @@ ProgOptions::ProgOptions()
     fAllOptions.add_options()
         ("help,h",                                                      "Print help")
         ("version,v",                                                   "Print version")
-        ("severity",      po::value<string>()->default_value("debug"),  "Log severity level (console): trace, debug, info, state, warn, error, fatal, nolog")
+        ("severity",      po::value<string>()->default_value(""),       "Log severity level (console): trace, debug, info, state, warn, error, fatal, nolog.")
         ("file-severity", po::value<string>()->default_value("debug"),  "Log severity level (file): trace, debug, info, state, warn, error, fatal, nolog")
         ("verbosity",     po::value<string>()->default_value("medium"), "Log verbosity level: veryhigh, high, medium, low")
         ("color",         po::value<bool  >()->default_value(true),     "Log color (true/false)")
@@ -120,8 +118,10 @@ void ProgOptions::ParseAll(const int argc, char const* const* argv, bool allowUn
 
     po::command_line_parser parser(argc, argv);
 
+    parser.options(fAllOptions);
+
     if (allowUnregistered) {
-        parser.options(fAllOptions).allow_unregistered();
+        parser.allow_unregistered();
     }
 
     using namespace po::command_line_style;
@@ -447,6 +447,4 @@ void ProgOptions::PrintOptionsRaw() const
     }
 }
 
-
+} // namespace fair::mq
-} // namespace mq
-} // namespace fair

fairmq/ProgOptions.h

@@ -26,9 +26,7 @@
 #include <vector>
 #include <stdexcept>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 struct PropertyNotFoundError : std::runtime_error { using std::runtime_error::runtime_error; };
@@ -270,7 +268,6 @@ class ProgOptions
     mutable std::mutex fMtx;
 };
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair
 
 #endif /* FAIR_MQ_PROGOPTIONS_H */

fairmq/ProgOptionsFwd.h

@@ -9,13 +9,10 @@
 #ifndef FAIR_MQ_PROGOPTIONSFWD_H
 #define FAIR_MQ_PROGOPTIONSFWD_H
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 class ProgOptions;
 }
-}
 
 using FairMQProgOptions = fair::mq::ProgOptions;
 

fairmq/Properties.cxx

@@ -7,17 +7,13 @@
  ********************************************************************************/
 
 #include <fairmq/Properties.h>
-#include <fairmq/Tools.h>
 
 #include <boost/filesystem.hpp>
 
 using namespace std;
-using namespace fair::mq::tools;
 using boost::any_cast;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 template<class T>
@@ -76,9 +72,11 @@ unordered_map<type_index, function<pair<string, string>(const Property&)>> Prope
     { type_index(typeid(const char*)),                     [](const Property& p) { return pair<string, string>{ string(any_cast<const char*>(p)), "string" }; } },
     { type_index(typeid(string)),                          [](const Property& p) { return pair<string, string>{ any_cast<string>(p), "string" }; } },
     { type_index(typeid(int)),                             [](const Property& p) { return getString<int>(p, "int"); } },
+    { type_index(typeid(short)),                           [](const Property& p) { return getString<short>(p, "short"); } },
     { type_index(typeid(long)),                            [](const Property& p) { return getString<long>(p, "long"); } },
     { type_index(typeid(long long)),                       [](const Property& p) { return getString<long long>(p, "long long"); } },
     { type_index(typeid(unsigned)),                        [](const Property& p) { return getString<unsigned>(p, "unsigned"); } },
+    { type_index(typeid(unsigned short)),                  [](const Property& p) { return getString<unsigned short>(p, "unsigned short"); } },
     { type_index(typeid(unsigned long)),                   [](const Property& p) { return getString<unsigned long>(p, "unsigned long"); } },
     { type_index(typeid(unsigned long long)),              [](const Property& p) { return getString<unsigned long long>(p, "unsigned long long"); } },
     { type_index(typeid(float)),                           [](const Property& p) { return getStringPair<float>(p, "float"); } },
@@ -92,9 +90,11 @@ unordered_map<type_index, function<pair<string, string>(const Property&)>> Prope
     { type_index(typeid(vector<unsigned char>)),           [](const Property& p) { return getStringPair<vector<unsigned char>>(p, "vector<unsigned char>"); } },
     { type_index(typeid(vector<string>)),                  [](const Property& p) { return getStringPair<vector<string>>(p, "vector<string>"); } },
     { type_index(typeid(vector<int>)),                     [](const Property& p) { return getStringPair<vector<int>>(p, "vector<int>"); } },
+    { type_index(typeid(vector<short>)),                   [](const Property& p) { return getStringPair<vector<short>>(p, "vector<short>"); } },
     { type_index(typeid(vector<long>)),                    [](const Property& p) { return getStringPair<vector<long>>(p, "vector<long>"); } },
     { type_index(typeid(vector<long long>)),               [](const Property& p) { return getStringPair<vector<long long>>(p, "vector<long long>"); } },
     { type_index(typeid(vector<unsigned>)),                [](const Property& p) { return getStringPair<vector<unsigned>>(p, "vector<unsigned>"); } },
+    { type_index(typeid(vector<unsigned short>)),          [](const Property& p) { return getStringPair<vector<unsigned short>>(p, "vector<unsigned short>"); } },
     { type_index(typeid(vector<unsigned long>)),           [](const Property& p) { return getStringPair<vector<unsigned long>>(p, "vector<unsigned long>"); } },
     { type_index(typeid(vector<unsigned long long>)),      [](const Property& p) { return getStringPair<vector<unsigned long long>>(p, "vector<unsigned long long>"); } },
     { type_index(typeid(vector<float>)),                   [](const Property& p) { return getStringPair<vector<float>>(p, "vector<float>"); } },
@@ -110,9 +110,11 @@ unordered_map<type_index, void(*)(const EventManager&, const string&, const Prop
     { type_index(typeid(const char*)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, string>(k, string(any_cast<const char*>(p))); } },
     { type_index(typeid(string)),                          [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, string>(k, any_cast<string>(p)); } },
     { type_index(typeid(int)),                             [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, int>(k, any_cast<int>(p)); } },
+    { type_index(typeid(short)),                           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, short>(k, any_cast<short>(p)); } },
     { type_index(typeid(long)),                            [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long>(k, any_cast<long>(p)); } },
     { type_index(typeid(long long)),                       [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long long>(k, any_cast<long long>(p)); } },
     { type_index(typeid(unsigned)),                        [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned>(k, any_cast<unsigned>(p)); } },
+    { type_index(typeid(unsigned short)),                  [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned short>(k, any_cast<unsigned short>(p)); } },
     { type_index(typeid(unsigned long)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned long>(k, any_cast<unsigned long>(p)); } },
     { type_index(typeid(unsigned long long)),              [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned long long>(k, any_cast<unsigned long long>(p)); } },
     { type_index(typeid(float)),                           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, float>(k, any_cast<float>(p)); } },
@@ -126,9 +128,11 @@ unordered_map<type_index, void(*)(const EventManager&, const string&, const Prop
     { type_index(typeid(vector<unsigned char>)),           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned char>>(k, any_cast<vector<unsigned char>>(p)); } },
     { type_index(typeid(vector<string>)),                  [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<string>>(k, any_cast<vector<string>>(p)); } },
     { type_index(typeid(vector<int>)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<int>>(k, any_cast<vector<int>>(p)); } },
+    { type_index(typeid(vector<short>)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<short>>(k, any_cast<vector<short>>(p)); } },
     { type_index(typeid(vector<long>)),                    [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long>>(k, any_cast<vector<long>>(p)); } },
     { type_index(typeid(vector<long long>)),               [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long long>>(k, any_cast<vector<long long>>(p)); } },
     { type_index(typeid(vector<unsigned>)),                [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned>>(k, any_cast<vector<unsigned>>(p)); } },
+    { type_index(typeid(vector<unsigned short>)),          [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned short>>(k, any_cast<vector<unsigned short>>(p)); } },
     { type_index(typeid(vector<unsigned long>)),           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned long>>(k, any_cast<vector<unsigned long>>(p)); } },
     { type_index(typeid(vector<unsigned long long>)),      [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned long long>>(k, any_cast<vector<unsigned long long>>(p)); } },
     { type_index(typeid(vector<float>)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<float>>(k, any_cast<vector<float>>(p)); } },
@@ -137,5 +141,4 @@ unordered_map<type_index, void(*)(const EventManager&, const string&, const Prop
     { type_index(typeid(vector<boost::filesystem::path>)), [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<boost::filesystem::path>>(k, any_cast<vector<boost::filesystem::path>>(p)); } },
 };
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair

fairmq/Properties.h

@@ -16,14 +16,13 @@
 #include <functional>
 #include <map>
 #include <unordered_map>
+#include <stdexcept>
 #include <string>
 #include <typeindex>
 #include <typeinfo>
 #include <utility> // pair
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 using Property = boost::any;
@@ -71,7 +70,6 @@ class PropertyHelper
     static std::unordered_map<std::type_index, std::function<std::pair<std::string, std::string>(const Property&)>> fTypeInfos;
 };
 
-}
 }
 
 #endif /* FAIR_MQ_PROPERTIES_H */

fairmq/StateMachine.cxx

@@ -7,7 +7,8 @@
  ********************************************************************************/
 
 #include <fairmq/StateMachine.h>
-#include <fairmq/Tools.h>
+
+#include <fairlogger/Logger.h>
 
 // Increase maximum number of boost::msm states (default is 10)
 // This #define has to be before any msm header includes
@@ -34,9 +35,7 @@ using namespace boost::msm::front;
 using namespace boost::msm::back;
 namespace bmpl = boost::mpl;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 namespace fsm
 {
@@ -238,8 +237,7 @@ struct Machine_ : public state_machine_def<Machine_>
 using FairMQFSM = state_machine<Machine_>;
 
 } // namespace fsm
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair
 
 using namespace fair::mq::fsm;
 using namespace fair::mq;

fairmq/StateMachine.h

@@ -11,16 +11,12 @@
 
 #include <fairmq/States.h>
 
-#include <fairlogger/Logger.h>
-
 #include <string>
 #include <memory>
 #include <functional>
 #include <stdexcept>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 class StateMachine
@@ -58,7 +54,6 @@ class StateMachine
     std::shared_ptr<void> fFsm;
 };
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair
 
 #endif /* FAIRMQSTATEMACHINE_H_ */

fairmq/StateQueue.h

@@ -17,9 +17,7 @@
 #include <utility> // pair
 #include <condition_variable>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 class StateQueue
@@ -88,7 +86,6 @@ class StateQueue
     std::condition_variable fCV;
 };
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair
 
-#endif /* FAIRMQSTATEQUEUE_H_ */
+#endif /* FAIRMQSTATEQUEUE_H_ */

fairmq/States.cxx

@@ -13,14 +13,13 @@
 
 using namespace std;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
-array<string, 15> stateNames =
+array<string, 16> stateNames =
 {
     {
+        "UNDEFINED",
         "OK",
         "ERROR",
         "IDLE",
@@ -41,6 +40,7 @@ array<string, 15> stateNames =
 
 unordered_map<string, State> states =
 {
+    { "UNDEFINED",           State::Undefined },
     { "OK",                  State::Ok },
     { "ERROR",               State::Error },
     { "IDLE",                State::Idle },
@@ -112,5 +112,4 @@ Transition GetTransition(const string& transition)
     return transitions.at(transition);
 }
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair

fairmq/States.h

@@ -13,13 +13,12 @@
 #include <ostream>
 #include <stdexcept>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 enum class State : int
 {
+    Undefined = 0,
     Ok,
     Error,
     Idle,
@@ -39,7 +38,7 @@ enum class State : int
 
 enum class Transition : int
 {
-    Auto,
+    Auto = 0,
     InitDevice,
     CompleteInit,
     Bind,
@@ -63,7 +62,6 @@ struct DeviceErrorState : std::runtime_error { using std::runtime_error::runtime
 inline std::ostream& operator<<(std::ostream& os, const State& state) { return os << GetStateName(state); }
 inline std::ostream& operator<<(std::ostream& os, const Transition& transition) { return os << GetTransitionName(transition); }
 
-} // namespace mq
+} // namespace fair::mq
-} // namespace fair
 
 #endif /* FAIRMQSTATES_H_ */

fairmq/SuboptParser.cxx

@@ -1,5 +1,5 @@
 /********************************************************************************
- *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public License (LGPL) version 3,             *
@@ -12,17 +12,19 @@
 /// @brief  Parser implementation for key-value subopt format
 
 #include <fairmq/SuboptParser.h>
+#include <fairmq/JSONParser.h>
+
+#include <fairlogger/Logger.h>
 
 #include <boost/property_tree/ptree.hpp>
+#include <string_view>
+#include <utility>   // make_pair
 #include <cstring>
-#include <utility> // make_pair
 
 using boost::property_tree::ptree;
 using namespace std;
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 enum channelOptionKeyIds
@@ -82,7 +84,16 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
         string argString(token);
         char* subopts = &argString[0];
         char* value = nullptr;
+        // Find either a : or a =. If we find the former first, we consider what is before it
+        // the channel name
+        char* firstSep = strpbrk(subopts, ":=");
+        if (firstSep && *firstSep == ':') {
+            channelName = std::string_view(subopts, firstSep - subopts);
+            channelProperties.put("name", channelName);
+            subopts = firstSep + 1;
+        }
         while (subopts && *subopts != 0 && *subopts != ' ') {
+            char* cur = subopts;
             int subopt = getsubopt(&subopts, (char**)channelOptionKeys, &value);
             if (subopt == NAME) {
                 channelName = value;
@@ -93,6 +104,8 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
                 socketsArray.push_back(make_pair("", socketProperties));
             } else if (subopt >= 0 && value != nullptr) {
                 channelProperties.put(channelOptionKeys[subopt], value);
+            } else if (subopt == -1) {
+                LOG(warn) << "Ignoring unknown argument in --channel-config: " << cur;
             }
         }
 
@@ -117,4 +130,3 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
 }
 
 }
-}

fairmq/SuboptParser.h

@@ -14,14 +14,12 @@
 #ifndef FAIR_MQ_SUBOPTPARSER_H
 #define FAIR_MQ_SUBOPTPARSER_H
 
-#include <fairmq/JSONParser.h>
+#include <fairmq/Properties.h>
 
 #include <vector>
 #include <string>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 /**
@@ -43,7 +41,6 @@ namespace mq
 
 Properties SuboptParser(const std::vector<std::string>& channelConfig, const std::string& deviceId);
 
-}
 }
 
 #endif /* FAIR_MQ_SUBOPTPARSER_H */

fairmq/Transports.h

@@ -9,15 +9,14 @@
 #ifndef FAIR_MQ_TRANSPORTS_H
 #define FAIR_MQ_TRANSPORTS_H
 
-#include <fairmq/tools/CppSTL.h>
+#include <fairmq/tools/Strings.h>
 
 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <unordered_map>
 
-namespace fair
+namespace fair::mq
-{
-namespace mq
 {
 
 enum class Transport
@@ -28,20 +27,11 @@ enum class Transport
     OFI
 };
 
-} /* namespace mq */
+struct TransportError : std::runtime_error { using std::runtime_error::runtime_error; };
-} /* namespace fair */
 
-namespace std
+} // namespace fair::mq
-{
 
-template<>
+namespace fair::mq
-struct hash<fair::mq::Transport> : fair::mq::tools::HashEnum<fair::mq::Transport> {};
-
-} /* namespace std */
-
-namespace fair
-{
-namespace mq
 {
 
 static std::unordered_map<std::string, Transport> TransportTypes {
@@ -58,7 +48,18 @@ static std::unordered_map<Transport, std::string> TransportNames {
     { Transport::OFI, "ofi" }
 };
 
-} /* namespace mq */
+inline std::string TransportName(Transport transport)
-} /* namespace fair */
+{
+    return TransportNames[transport];
+}
+
+inline Transport TransportType(const std::string& transport)
+try {
+    return TransportTypes.at(transport);
+} catch (std::out_of_range&) {
+    throw TransportError(tools::ToString("Unknown transport provided: ", transport));
+}
+
+} // namespace fair::mq
 
 #endif /* FAIR_MQ_TRANSPORTS_H */

fairmq/Version.h.in

@@ -21,7 +21,7 @@
 #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-2020 GSI"
+#define FAIRMQ_COPYRIGHT "2012-2021 GSI"
 #define FAIRMQ_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
 
 #endif // FAIR_MQ_VERSION_H

fairmq/devices/BenchmarkSampler.h

@@ -1,35 +1,40 @@
 /********************************************************************************
- * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#ifndef FAIRMQBENCHMARKSAMPLER_H_
+#ifndef FAIR_MQ_BENCHMARKSAMPLER_H
-#define FAIRMQBENCHMARKSAMPLER_H_
+#define FAIR_MQ_BENCHMARKSAMPLER_H
 
-#include "../FairMQLogger.h"
+#include <fairmq/Device.h>
-#include "FairMQDevice.h"
+#include <fairmq/tools/RateLimit.h>
-#include "tools/RateLimit.h"
 
-#include <atomic>
 #include <chrono>
 #include <cstddef>   // size_t
 #include <cstdint>   // uint64_t
+#include <cstring>   // memset
+#include <fairlogger/Logger.h>
 #include <string>
 
+namespace fair::mq
+{
+
 /**
  * Sampler to generate traffic for benchmarking.
  */
 
-class FairMQBenchmarkSampler : public FairMQDevice
+class BenchmarkSampler : public Device
 {
   public:
-    FairMQBenchmarkSampler()
+    BenchmarkSampler()
         : fMultipart(false)
+        , fMemSet(false)
         , fNumParts(1)
         , fMsgSize(10000)
+        , fMsgAlignment(0)
         , fMsgRate(0)
         , fNumIterations(0)
         , fMaxIterations(0)
@@ -39,8 +44,10 @@ class FairMQBenchmarkSampler : public FairMQDevice
     void InitTask() override
     {
         fMultipart = fConfig->GetProperty<bool>("multipart");
+        fMemSet = fConfig->GetProperty<bool>("memset");
         fNumParts = fConfig->GetProperty<size_t>("num-parts");
         fMsgSize = fConfig->GetProperty<size_t>("msg-size");
+        fMsgAlignment = fConfig->GetProperty<size_t>("msg-alignment");
         fMsgRate = fConfig->GetProperty<float>("msg-rate");
         fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
         fOutChannelName = fConfig->GetProperty<std::string>("out-channel");
@@ -51,8 +58,6 @@ class FairMQBenchmarkSampler : public FairMQDevice
         // store the channel reference to avoid traversing the map on every loop iteration
         FairMQChannel& dataOutChannel = fChannels.at(fOutChannelName).at(0);
 
-        FairMQMessagePtr baseMsg(dataOutChannel.NewMessage(fMsgSize));
-
         LOG(info) << "Starting the benchmark with message size of " << fMsgSize << " and " << fMaxIterations << " iterations.";
         auto tStart = std::chrono::high_resolution_clock::now();
 
@@ -63,7 +68,10 @@ class FairMQBenchmarkSampler : public FairMQDevice
                 FairMQParts parts;
 
                 for (size_t i = 0; i < fNumParts; ++i) {
-                    parts.AddPart(dataOutChannel.NewMessage(fMsgSize));
+                    parts.AddPart(dataOutChannel.NewMessage(fMsgSize, fair::mq::Alignment{fMsgAlignment}));
+                    if (fMemSet) {
+                        std::memset(parts.At(i)->GetData(), 0, parts.At(i)->GetSize());
+                    }
                 }
 
                 if (dataOutChannel.Send(parts) >= 0) {
@@ -75,7 +83,10 @@ class FairMQBenchmarkSampler : public FairMQDevice
                     ++fNumIterations;
                 }
             } else {
-                FairMQMessagePtr msg(dataOutChannel.NewMessage(fMsgSize));
+                FairMQMessagePtr msg(dataOutChannel.NewMessage(fMsgSize, fair::mq::Alignment{fMsgAlignment}));
+                if (fMemSet) {
+                    std::memset(msg->GetData(), 0, msg->GetSize());
+                }
 
                 if (dataOutChannel.Send(msg) >= 0) {
                     if (fMaxIterations > 0) {
@@ -97,17 +108,18 @@ class FairMQBenchmarkSampler : public FairMQDevice
         LOG(info) << "Done " << fNumIterations << " iterations in " << std::chrono::duration<double, std::milli>(tEnd - tStart).count() << "ms.";
     }
 
-    virtual ~FairMQBenchmarkSampler() {}
-
   protected:
     bool fMultipart;
+    bool fMemSet;
     size_t fNumParts;
     size_t fMsgSize;
-    std::atomic<int> fMsgCounter;
+    size_t fMsgAlignment;
     float fMsgRate;
     uint64_t fNumIterations;
     uint64_t fMaxIterations;
     std::string fOutChannelName;
 };
 
-#endif /* FAIRMQBENCHMARKSAMPLER_H_ */
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_BENCHMARKSAMPLER_H */

fairmq/devices/FairMQMerger.cxx

@@ -1,122 +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"                       *
- ********************************************************************************/
-/**
- * FairMQMerger.cxx
- *
- * @since 2012-12-06
- * @author D. Klein, A. Rybalchenko
- */
-
-#include "FairMQMerger.h"
-#include "../FairMQLogger.h"
-#include "../FairMQPoller.h"
-
-using namespace std;
-
-FairMQMerger::FairMQMerger()
-    : fMultipart(true)
-    , fInChannelName("data-in")
-    , fOutChannelName("data-out")
-{
-}
-
-void FairMQMerger::RegisterChannelEndpoints()
-{
-    RegisterChannelEndpoint(fInChannelName, 1, 10000);
-    RegisterChannelEndpoint(fOutChannelName, 1, 1);
-
-    PrintRegisteredChannels();
-}
-
-FairMQMerger::~FairMQMerger()
-{
-}
-
-void FairMQMerger::InitTask()
-{
-    fMultipart = fConfig->GetProperty<bool>("multipart");
-    fInChannelName = fConfig->GetProperty<string>("in-channel");
-    fOutChannelName = fConfig->GetProperty<string>("out-channel");
-}
-
-void FairMQMerger::Run()
-{
-    int numInputs = fChannels.at(fInChannelName).size();
-
-    vector<FairMQChannel*> chans;
-
-    for (auto& chan : fChannels.at(fInChannelName))
-    {
-        chans.push_back(&chan);
-    }
-
-    FairMQPollerPtr poller(NewPoller(chans));
-
-    if (fMultipart)
-    {
-        while (!NewStatePending())
-        {
-            poller->Poll(100);
-
-            // Loop over the data input channels.
-            for (int i = 0; i < numInputs; ++i)
-            {
-                // Check if the channel has data ready to be received.
-                if (poller->CheckInput(i))
-                {
-                    FairMQParts payload;
-
-                    if (Receive(payload, fInChannelName, i) >= 0)
-                    {
-                        if (Send(payload, fOutChannelName) < 0)
-                        {
-                            LOG(debug) << "Transfer interrupted";
-                            break;
-                        }
-                    }
-                    else
-                    {
-                        LOG(debug) << "Transfer interrupted";
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    else
-    {
-        while (!NewStatePending())
-        {
-            poller->Poll(100);
-
-            // Loop over the data input channels.
-            for (int i = 0; i < numInputs; ++i)
-            {
-                // Check if the channel has data ready to be received.
-                if (poller->CheckInput(i))
-                {
-                    FairMQMessagePtr payload(fTransportFactory->CreateMessage());
-
-                    if (Receive(payload, fInChannelName, i) >= 0)
-                    {
-                        if (Send(payload, fOutChannelName) < 0)
-                        {
-                            LOG(debug) << "Transfer interrupted";
-                            break;
-                        }
-                    }
-                    else
-                    {
-                        LOG(debug) << "Transfer interrupted";
-                        break;
-                    }
-                }
-            }
-        }
-    }
-}

fairmq/devices/FairMQMerger.h

@@ -1,38 +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"                       *
- ********************************************************************************/
-/**
- * FairMQMerger.h
- *
- * @since 2012-12-06
- * @author D. Klein, A. Rybalchenko
- */
-
-#ifndef FAIRMQMERGER_H_
-#define FAIRMQMERGER_H_
-
-#include "FairMQDevice.h"
-
-#include <string>
-
-class FairMQMerger : public FairMQDevice
-{
-  public:
-    FairMQMerger();
-    virtual ~FairMQMerger();
-
-  protected:
-    bool fMultipart;
-    std::string fInChannelName;
-    std::string fOutChannelName;
-
-    virtual void RegisterChannelEndpoints() override;
-    virtual void Run() override;
-    virtual void InitTask() override;
-};
-
-#endif /* FAIRMQMERGER_H_ */

fairmq/devices/FairMQMultiplier.cxx

@@ -1,110 +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"                       *
- ********************************************************************************/
-
-#include "FairMQMultiplier.h"
-
-#include "../FairMQLogger.h"
-
-using namespace std;
-
-FairMQMultiplier::FairMQMultiplier()
-    : fMultipart(true)
-    , fNumOutputs(0)
-    , fInChannelName()
-    , fOutChannelNames()
-{
-}
-
-FairMQMultiplier::~FairMQMultiplier()
-{
-}
-
-void FairMQMultiplier::InitTask()
-{
-    fMultipart = fConfig->GetProperty<bool>("multipart");
-    fInChannelName = fConfig->GetProperty<string>("in-channel");
-    fOutChannelNames = fConfig->GetProperty<vector<string>>("out-channel");
-    fNumOutputs = fChannels.at(fOutChannelNames.at(0)).size();
-
-    if (fMultipart)
-    {
-        OnData(fInChannelName, &FairMQMultiplier::HandleMultipartData);
-    }
-    else
-    {
-        OnData(fInChannelName, &FairMQMultiplier::HandleSingleData);
-    }
-}
-
-bool FairMQMultiplier::HandleSingleData(std::unique_ptr<FairMQMessage>& payload, int /*index*/)
-{
-    for (unsigned int i = 0; i < fOutChannelNames.size() - 1; ++i) // all except last channel
-    {
-        for (unsigned int j = 0; j < fChannels.at(fOutChannelNames.at(i)).size(); ++j) // all subChannels in a channel
-        {
-            FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
-            msgCopy->Copy(*payload);
-
-            Send(msgCopy, fOutChannelNames.at(i), j);
-        }
-    }
-
-    unsigned int lastChannelSize = fChannels.at(fOutChannelNames.back()).size();
-
-    for (unsigned int i = 0; i < lastChannelSize - 1; ++i) // iterate over all except last subChannels of the last channel
-    {
-        FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
-        msgCopy->Copy(*payload);
-
-        Send(msgCopy, fOutChannelNames.back(), i);
-    }
-
-    Send(payload, fOutChannelNames.back(), lastChannelSize - 1); // send final message to last subChannel of last channel
-
-    return true;
-}
-
-bool FairMQMultiplier::HandleMultipartData(FairMQParts& payload, int /*index*/)
-{
-    for (unsigned int i = 0; i < fOutChannelNames.size() - 1; ++i) // all except last channel
-    {
-        for (unsigned int j = 0; j < fChannels.at(fOutChannelNames.at(i)).size(); ++j) // all subChannels in a channel
-        {
-            FairMQParts parts;
-
-            for (int k = 0; k < payload.Size(); ++k)
-            {
-                FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
-                msgCopy->Copy(payload.AtRef(k));
-                parts.AddPart(std::move(msgCopy));
-            }
-
-            Send(parts, fOutChannelNames.at(i), j);
-        }
-    }
-
-    unsigned int lastChannelSize = fChannels.at(fOutChannelNames.back()).size();
-
-    for (unsigned int i = 0; i < lastChannelSize - 1; ++i) // iterate over all except last subChannels of the last channel
-    {
-        FairMQParts parts;
-
-        for (int k = 0; k < payload.Size(); ++k)
-        {
-            FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
-            msgCopy->Copy(payload.AtRef(k));
-            parts.AddPart(std::move(msgCopy));
-        }
-
-        Send(parts, fOutChannelNames.back(), i);
-    }
-
-    Send(payload, fOutChannelNames.back(), lastChannelSize - 1); // send final message to last subChannel of last channel
-
-    return true;
-}

fairmq/devices/FairMQMultiplier.h

@@ -1,34 +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"                       *
- ********************************************************************************/
-
-#ifndef FAIRMQMULTIPLIER_H_
-#define FAIRMQMULTIPLIER_H_
-
-#include "FairMQDevice.h"
-
-#include <string>
-
-class FairMQMultiplier : public FairMQDevice
-{
-  public:
-    FairMQMultiplier();
-    virtual ~FairMQMultiplier();
-
-  protected:
-    bool fMultipart;
-    int fNumOutputs;
-    std::string fInChannelName;
-    std::vector<std::string> fOutChannelNames;
-
-    virtual void InitTask();
-
-    bool HandleSingleData(std::unique_ptr<FairMQMessage>&, int);
-    bool HandleMultipartData(FairMQParts&, int);
-};
-
-#endif /* FAIRMQMULTIPLIER_H_ */

fairmq/devices/FairMQProxy.cxx

@@ -1,81 +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"                       *
- ********************************************************************************/
-/**
- * FairMQProxy.cxx
- *
- * @since 2013-10-02
- * @author A. Rybalchenko
- */
-
-#include "FairMQProxy.h"
-
-#include "../FairMQLogger.h"
-
-using namespace std;
-
-FairMQProxy::FairMQProxy()
-    : fMultipart(true)
-    , fInChannelName()
-    , fOutChannelName()
-{
-}
-
-FairMQProxy::~FairMQProxy()
-{
-}
-
-void FairMQProxy::InitTask()
-{
-    fMultipart = fConfig->GetProperty<bool>("multipart");
-    fInChannelName = fConfig->GetProperty<string>("in-channel");
-    fOutChannelName = fConfig->GetProperty<string>("out-channel");
-}
-
-void FairMQProxy::Run()
-{
-    if (fMultipart)
-    {
-        while (!NewStatePending())
-        {
-            FairMQParts payload;
-            if (Receive(payload, fInChannelName) >= 0)
-            {
-                if (Send(payload, fOutChannelName) < 0)
-                {
-                    LOG(debug) << "Transfer interrupted";
-                    break;
-                }
-            }
-            else
-            {
-                LOG(debug) << "Transfer interrupted";
-                break;
-            }
-        }
-    }
-    else
-    {
-        while (!NewStatePending())
-        {
-            unique_ptr<FairMQMessage> payload(fTransportFactory->CreateMessage());
-            if (Receive(payload, fInChannelName) >= 0)
-            {
-                if (Send(payload, fOutChannelName) < 0)
-                {
-                    LOG(debug) << "Transfer interrupted";
-                    break;
-                }
-            }
-            else
-            {
-                LOG(debug) << "Transfer interrupted";
-                break;
-            }
-        }
-    }
-}

fairmq/devices/FairMQProxy.h

@@ -1,37 +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"                       *
- ********************************************************************************/
-/**
- * FairMQProxy.h
- *
- * @since 2013-10-02
- * @author A. Rybalchenko
- */
-
-#ifndef FAIRMQPROXY_H_
-#define FAIRMQPROXY_H_
-
-#include "FairMQDevice.h"
-
-#include <string>
-
-class FairMQProxy : public FairMQDevice
-{
-  public:
-    FairMQProxy();
-    virtual ~FairMQProxy();
-
-  protected:
-    bool fMultipart;
-    std::string fInChannelName;
-    std::string fOutChannelName;
-
-    virtual void Run();
-    virtual void InitTask();
-};
-
-#endif /* FAIRMQPROXY_H_ */

fairmq/devices/FairMQSink.h

@@ -1,93 +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"                       *
- ********************************************************************************/
-/**
- * FairMQSink.h
- *
- * @since 2013-01-09
- * @author D. Klein, A. Rybalchenko
- */
-
-#ifndef FAIRMQSINK_H_
-#define FAIRMQSINK_H_
-
-#include "../FairMQDevice.h"
-#include "../FairMQLogger.h"
-
-#include <chrono>
-#include <string>
-
-// template<typename OutputPolicy>
-class FairMQSink : public FairMQDevice   //, public OutputPolicy
-{
-  public:
-    FairMQSink()
-        : fMultipart(false)
-        , fMaxIterations(0)
-        , fNumIterations(0)
-        , fInChannelName()
-    {}
-
-    virtual ~FairMQSink() {}
-
-  protected:
-    bool fMultipart;
-    uint64_t fMaxIterations;
-    uint64_t fNumIterations;
-    std::string fInChannelName;
-
-    virtual void InitTask()
-    {
-        fMultipart = fConfig->GetProperty<bool>("multipart");
-        fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
-        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
-    }
-
-    virtual void Run()
-    {
-        // store the channel reference to avoid traversing the map on every loop iteration
-        FairMQChannel& dataInChannel = fChannels.at(fInChannelName).at(0);
-
-        LOG(info) << "Starting the benchmark and expecting to receive " << fMaxIterations << " messages.";
-        auto tStart = std::chrono::high_resolution_clock::now();
-
-        while (!NewStatePending()) {
-            if (fMultipart) {
-                FairMQParts parts;
-
-                if (dataInChannel.Receive(parts) >= 0) {
-                    if (fMaxIterations > 0) {
-                        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++;
-                }
-            }
-        }
-
-        auto tEnd = std::chrono::high_resolution_clock::now();
-
-        LOG(info) << "Leaving RUNNING state. Received " << fNumIterations << " messages in "
-                  << std::chrono::duration<double, std::milli>(tEnd - tStart).count() << "ms.";
-    }
-};
-
-#endif /* FAIRMQSINK_H_ */

fairmq/devices/FairMQSplitter.cxx

@@ -1,74 +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"                       *
- ********************************************************************************/
-/**
- * FairMQSplitter.cxx
- *
- * @since 2012-12-06
- * @author D. Klein, A. Rybalchenko
- */
-
-#include "FairMQSplitter.h"
-
-#include "../FairMQLogger.h"
-
-using namespace std;
-
-FairMQSplitter::FairMQSplitter()
-    : fMultipart(true)
-    , fNumOutputs(0)
-    , fDirection(0)
-    , fInChannelName()
-    , fOutChannelName()
-{
-}
-
-FairMQSplitter::~FairMQSplitter()
-{
-}
-
-void FairMQSplitter::InitTask()
-{
-    fMultipart = fConfig->GetProperty<bool>("multipart");
-    fInChannelName = fConfig->GetProperty<string>("in-channel");
-    fOutChannelName = fConfig->GetProperty<string>("out-channel");
-    fNumOutputs = fChannels.at(fOutChannelName).size();
-    fDirection = 0;
-
-    if (fMultipart)
-    {
-        OnData(fInChannelName, &FairMQSplitter::HandleMultipartData);
-    }
-    else
-    {
-        OnData(fInChannelName, &FairMQSplitter::HandleSingleData);
-    }
-}
-
-bool FairMQSplitter::HandleSingleData(FairMQMessagePtr& payload, int /*index*/)
-{
-    Send(payload, fOutChannelName, fDirection);
-
-    if (++fDirection >= fNumOutputs)
-    {
-        fDirection = 0;
-    }
-
-    return true;
-}
-
-bool FairMQSplitter::HandleMultipartData(FairMQParts& payload, int /*index*/)
-{
-    Send(payload, fOutChannelName, fDirection);
-
-    if (++fDirection >= fNumOutputs)
-    {
-        fDirection = 0;
-    }
-
-    return true;
-}

fairmq/devices/FairMQSplitter.h

@@ -1,41 +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"                       *
- ********************************************************************************/
-/**
- * FairMQSplitter.h
- *
- * @since 2012-12-06
- * @author D. Klein, A. Rybalchenko
- */
-
-#ifndef FAIRMQSPLITTER_H_
-#define FAIRMQSPLITTER_H_
-
-#include "FairMQDevice.h"
-
-#include <string>
-
-class FairMQSplitter : public FairMQDevice
-{
-  public:
-    FairMQSplitter();
-    virtual ~FairMQSplitter();
-
-  protected:
-    bool fMultipart;
-    int fNumOutputs;
-    int fDirection;
-    std::string fInChannelName;
-    std::string fOutChannelName;
-
-    virtual void InitTask();
-
-    bool HandleSingleData(std::unique_ptr<FairMQMessage>&, int);
-    bool HandleMultipartData(FairMQParts&, int);
-};
-
-#endif /* FAIRMQSPLITTER_H_ */

fairmq/devices/Merger.h

@@ -0,0 +1,113 @@
+/********************************************************************************
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_MERGER_H
+#define FAIR_MQ_MERGER_H
+
+#include <FairMQPoller.h>
+#include <fairmq/Device.h>
+
+#include <fairlogger/Logger.h>
+#include <string>
+#include <vector>
+
+namespace fair::mq
+{
+
+class Merger : public Device
+{
+  public:
+    Merger()
+        : fMultipart(true)
+        , fInChannelName("data-in")
+        , fOutChannelName("data-out")
+    {}
+
+  protected:
+    bool fMultipart;
+    std::string fInChannelName;
+    std::string fOutChannelName;
+
+    void InitTask() override
+    {
+        fMultipart = fConfig->GetProperty<bool>("multipart");
+        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
+        fOutChannelName = fConfig->GetProperty<std::string>("out-channel");
+    }
+
+    void RegisterChannelEndpoints() override
+    {
+        RegisterChannelEndpoint(fInChannelName, 1, 10000);
+        RegisterChannelEndpoint(fOutChannelName, 1, 1);
+
+        PrintRegisteredChannels();
+    }
+
+    void Run() override
+    {
+        int numInputs = fChannels.at(fInChannelName).size();
+
+        std::vector<FairMQChannel*> chans;
+
+        for (auto& chan : fChannels.at(fInChannelName)) {
+            chans.push_back(&chan);
+        }
+
+        FairMQPollerPtr poller(NewPoller(chans));
+
+        if (fMultipart) {
+            while (!NewStatePending()) {
+                poller->Poll(100);
+
+                // Loop over the data input channels.
+                for (int i = 0; i < numInputs; ++i) {
+                    // Check if the channel has data ready to be received.
+                    if (poller->CheckInput(i)) {
+                        FairMQParts payload;
+
+                        if (Receive(payload, fInChannelName, i) >= 0) {
+                            if (Send(payload, fOutChannelName) < 0) {
+                                LOG(debug) << "Transfer interrupted";
+                                break;
+                            }
+                        } else {
+                            LOG(debug) << "Transfer interrupted";
+                            break;
+                        }
+                    }
+                }
+            }
+        } else {
+            while (!NewStatePending()) {
+                poller->Poll(100);
+
+                // Loop over the data input channels.
+                for (int i = 0; i < numInputs; ++i) {
+                    // Check if the channel has data ready to be received.
+                    if (poller->CheckInput(i)) {
+                        FairMQMessagePtr payload(fTransportFactory->CreateMessage());
+
+                        if (Receive(payload, fInChannelName, i) >= 0) {
+                            if (Send(payload, fOutChannelName) < 0) {
+                                LOG(debug) << "Transfer interrupted";
+                                break;
+                            }
+                        } else {
+                            LOG(debug) << "Transfer interrupted";
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_MERGER_H */

fairmq/devices/Multiplier.h

@@ -0,0 +1,114 @@
+/********************************************************************************
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_MULTIPLIER_H
+#define FAIR_MQ_MULTIPLIER_H
+
+#include <fairmq/Device.h>
+
+#include <string>
+#include <vector>
+
+namespace fair::mq
+{
+
+class Multiplier : public Device
+{
+  public:
+    Multiplier()
+        : fMultipart(true)
+        , fNumOutputs(0)
+        , fInChannelName()
+        , fOutChannelNames()
+    {}
+
+  protected:
+    bool fMultipart;
+    int fNumOutputs;
+    std::string fInChannelName;
+    std::vector<std::string> fOutChannelNames;
+
+    void InitTask() override
+    {
+        fMultipart = fConfig->GetProperty<bool>("multipart");
+        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
+        fOutChannelNames = fConfig->GetProperty<std::vector<std::string>>("out-channel");
+        fNumOutputs = fChannels.at(fOutChannelNames.at(0)).size();
+
+        if (fMultipart) {
+            OnData(fInChannelName, &Multiplier::HandleMultipartData);
+        } else {
+            OnData(fInChannelName, &Multiplier::HandleSingleData);
+        }
+    }
+
+
+    bool HandleSingleData(std::unique_ptr<FairMQMessage>& payload, int)
+    {
+        for (unsigned int i = 0; i < fOutChannelNames.size() - 1; ++i) { // all except last channel
+            for (unsigned int j = 0; j < fChannels.at(fOutChannelNames.at(i)).size(); ++j) { // all subChannels in a channel
+                FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
+                msgCopy->Copy(*payload);
+
+                Send(msgCopy, fOutChannelNames.at(i), j);
+            }
+        }
+
+        unsigned int lastChannelSize = fChannels.at(fOutChannelNames.back()).size();
+
+        for (unsigned int i = 0; i < lastChannelSize - 1; ++i) { // iterate over all except last subChannels of the last channel
+            FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
+            msgCopy->Copy(*payload);
+
+            Send(msgCopy, fOutChannelNames.back(), i);
+        }
+
+        Send(payload, fOutChannelNames.back(), lastChannelSize - 1); // send final message to last subChannel of last channel
+
+        return true;
+    }
+
+    bool HandleMultipartData(FairMQParts& payload, int)
+    {
+        for (unsigned int i = 0; i < fOutChannelNames.size() - 1; ++i) { // all except last channel
+            for (unsigned int j = 0; j < fChannels.at(fOutChannelNames.at(i)).size(); ++j) { // all subChannels in a channel
+                FairMQParts parts;
+
+                for (int k = 0; k < payload.Size(); ++k) {
+                    FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
+                    msgCopy->Copy(payload.AtRef(k));
+                    parts.AddPart(std::move(msgCopy));
+                }
+
+                Send(parts, fOutChannelNames.at(i), j);
+            }
+        }
+
+        unsigned int lastChannelSize = fChannels.at(fOutChannelNames.back()).size();
+
+        for (unsigned int i = 0; i < lastChannelSize - 1; ++i) { // iterate over all except last subChannels of the last channel
+            FairMQParts parts;
+
+            for (int k = 0; k < payload.Size(); ++k) {
+                FairMQMessagePtr msgCopy(fTransportFactory->CreateMessage());
+                msgCopy->Copy(payload.AtRef(k));
+                parts.AddPart(std::move(msgCopy));
+            }
+
+            Send(parts, fOutChannelNames.back(), i);
+        }
+
+        Send(payload, fOutChannelNames.back(), lastChannelSize - 1); // send final message to last subChannel of last channel
+
+        return true;
+    }
+};
+
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_MULTIPLIER_H */

fairmq/devices/Proxy.h

@@ -0,0 +1,74 @@
+/********************************************************************************
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_PROXY_H
+#define FAIR_MQ_PROXY_H
+
+#include <fairmq/Device.h>
+
+#include <string>
+
+namespace fair::mq
+{
+
+class Proxy : public Device
+{
+  public:
+    Proxy()
+        : fMultipart(true)
+        , fInChannelName()
+        , fOutChannelName()
+    {}
+
+  protected:
+    bool fMultipart;
+    std::string fInChannelName;
+    std::string fOutChannelName;
+
+    void InitTask() override
+    {
+        fMultipart = fConfig->GetProperty<bool>("multipart");
+        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
+        fOutChannelName = fConfig->GetProperty<std::string>("out-channel");
+    }
+
+    void Run() override
+    {
+        if (fMultipart) {
+            while (!NewStatePending()) {
+                FairMQParts payload;
+                if (Receive(payload, fInChannelName) >= 0) {
+                    if (Send(payload, fOutChannelName) < 0) {
+                        LOG(debug) << "Transfer interrupted";
+                        break;
+                    }
+                } else {
+                    LOG(debug) << "Transfer interrupted";
+                    break;
+                }
+            }
+        } else {
+            while (!NewStatePending()) {
+                FairMQMessagePtr payload(fTransportFactory->CreateMessage());
+                if (Receive(payload, fInChannelName) >= 0) {
+                    if (Send(payload, fOutChannelName) < 0) {
+                        LOG(debug) << "Transfer interrupted";
+                        break;
+                    }
+                } else {
+                    LOG(debug) << "Transfer interrupted";
+                    break;
+                }
+            }
+        }
+    }
+};
+
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_PROXY_H */

fairmq/devices/README.md

@@ -2,9 +2,9 @@
 
 With FairMQ several generic devices are provided:
 
-- **FairMQBenchmarkSampler**: generates random data of configurable size and at configurable rate and sends it out on an output channel.
+- **BenchmarkSampler**: generates random data of configurable size and at configurable rate and sends it out on an output channel.
-- **FairMQSink**: receives messages on the input channel and simply discards them.
+- **Sink**: receives messages on the input channel and simply discards them.
-- **FairMQMerger**: receives data from multiple input channels and forwards it to a single output channel.
+- **Merger**: receives data from multiple input channels and forwards it to a single output channel.
-- **FairMQSplitter**: receives messages on a single input channels and round-robins them among multiple output channels (which can have different socket types).
+- **Splitter**: receives messages on a single input channels and round-robins them among multiple output channels (which can have different socket types).
-- **FairMQMultiplier**: receives data from a single input channel and multiplies (copies) it to two or more output channels.
+- **Multiplier**: receives data from a single input channel and multiplies (copies) it to two or more output channels.
-- **FairMQProxy**: connects input channel to output channel, where both can have different socket types and multiple peers.
+- **Proxy**: connects input channel to output channel, where both can have different socket types and multiple peers.

fairmq/devices/Sink.h

@@ -0,0 +1,146 @@
+/********************************************************************************
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_SINK_H
+#define FAIR_MQ_SINK_H
+
+#include <FairMQPoller.h>
+#include <fairmq/Device.h>
+#include <fairmq/tools/Strings.h>
+
+#include <chrono>
+#include <fairlogger/Logger.h>
+#include <fstream>
+#include <string>
+#include <stdexcept>
+
+namespace fair::mq
+{
+
+class Sink : public Device
+{
+  public:
+    Sink()
+        : fMultipart(false)
+        , fMaxIterations(0)
+        , fNumIterations(0)
+        , fMaxFileSize(0)
+        , fBytesWritten(0)
+        , fInChannelName()
+        , fOutFilename()
+    {}
+
+  protected:
+    bool fMultipart;
+    uint64_t fMaxIterations;
+    uint64_t fNumIterations;
+    uint64_t fMaxFileSize;
+    uint64_t fBytesWritten;
+    std::string fInChannelName;
+    std::string fOutFilename;
+    std::fstream fOutputFile;
+
+    void InitTask() override
+    {
+        fMultipart     = fConfig->GetProperty<bool>("multipart");
+        fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
+        fMaxFileSize   = fConfig->GetProperty<uint64_t>("max-file-size");
+        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
+        fOutFilename   = fConfig->GetProperty<std::string>("out-filename");
+
+        fBytesWritten = 0;
+    }
+
+    void Run() override
+    {
+        // store the channel reference to avoid traversing the map on every loop iteration
+        FairMQChannel& dataInChannel = fChannels.at(fInChannelName).at(0);
+
+        LOG(info) << "Starting sink and expecting to receive " << fMaxIterations << " messages.";
+        auto tStart = std::chrono::high_resolution_clock::now();
+
+        if (!fOutFilename.empty()) {
+            LOG(debug) << "Incoming messages will be written to file: " << fOutFilename;
+            if (fMaxFileSize != 0) {
+                LOG(debug) << "File output will stop after " << fMaxFileSize << " bytes";
+            } else {
+                LOG(debug) << "ATTENTION: --max-file-size is 0 - output file will continue to grow until sink is stopped";
+            }
+
+            fOutputFile.open(fOutFilename, std::ios::out | std::ios::binary);
+            if (!fOutputFile) {
+                LOG(error) << "Could not open '" << fOutFilename;
+                throw std::runtime_error(fair::mq::tools::ToString("Could not open '", fOutFilename));
+            }
+        }
+
+        while (!NewStatePending()) {
+            if (fMultipart) {
+                FairMQParts parts;
+                if (dataInChannel.Receive(parts) < 0) {
+                    continue;
+                }
+                if (fOutputFile.is_open()) {
+                    for (const auto& part : parts) {
+                        WriteToFile(static_cast<const char*>(part->GetData()), part->GetSize());
+                    }
+                }
+            } else {
+                FairMQMessagePtr msg(dataInChannel.NewMessage());
+                if (dataInChannel.Receive(msg) < 0) {
+                    continue;
+                }
+                if (fOutputFile.is_open()) {
+                    WriteToFile(static_cast<const char*>(msg->GetData()), msg->GetSize());
+                }
+            }
+
+            if (fMaxFileSize > 0 && fBytesWritten >= fMaxFileSize) {
+                LOG(info) << "Written " << fBytesWritten << " bytes, stopping...";
+                break;
+            }
+            if (fMaxIterations > 0) {
+                if (fNumIterations >= fMaxIterations) {
+                    LOG(info) << "Configured maximum number of iterations reached.";
+                    break;
+                }
+            }
+            fNumIterations++;
+        }
+
+        if (fOutputFile.is_open()) {
+            fOutputFile.flush();
+            fOutputFile.close();
+        }
+
+        auto tEnd = std::chrono::high_resolution_clock::now();
+        auto ms = std::chrono::duration<double, std::milli>(tEnd - tStart).count();
+        LOG(info) << "Received " << fNumIterations << " messages in " << ms << "ms.";
+        if (!fOutFilename.empty()) {
+            auto sec = std::chrono::duration<double>(tEnd - tStart).count();
+            LOG(info) << "Closed '" << fOutFilename << "' after writing " << fBytesWritten << " bytes."
+                      << "(" << (fBytesWritten / (1000. * 1000.)) / sec << " MB/s)";
+        }
+
+        LOG(info) << "Leaving RUNNING state.";
+    }
+
+    void WriteToFile(const char* ptr, size_t size)
+    {
+        fOutputFile.write(ptr, size);
+        if (fOutputFile.bad()) {
+            LOG(error) << "failed writing to file";
+            throw std::runtime_error("failed writing to file");
+        }
+        fBytesWritten += size;
+    }
+};
+
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_SINK_H */

fairmq/devices/Splitter.h

@@ -0,0 +1,67 @@
+/********************************************************************************
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_SPLITTER_H
+#define FAIR_MQ_SPLITTER_H
+
+#include <fairmq/Device.h>
+
+#include <string>
+
+namespace fair::mq
+{
+
+class Splitter : public Device
+{
+  public:
+    Splitter()
+        : fMultipart(true)
+        , fNumOutputs(0)
+        , fDirection(0)
+        , fInChannelName()
+        , fOutChannelName()
+    {}
+
+  protected:
+    bool fMultipart;
+    int fNumOutputs;
+    int fDirection;
+    std::string fInChannelName;
+    std::string fOutChannelName;
+
+    void InitTask() override
+    {
+        fMultipart = fConfig->GetProperty<bool>("multipart");
+        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
+        fOutChannelName = fConfig->GetProperty<std::string>("out-channel");
+        fNumOutputs = fChannels.at(fOutChannelName).size();
+        fDirection = 0;
+
+        if (fMultipart) {
+            OnData(fInChannelName, &Splitter::HandleData<FairMQParts>);
+        } else {
+            OnData(fInChannelName, &Splitter::HandleData<FairMQMessagePtr>);
+        }
+    }
+
+    template<typename T>
+    bool HandleData(T& payload, int)
+    {
+        Send(payload, fOutChannelName, fDirection);
+
+        if (++fDirection >= fNumOutputs) {
+            fDirection = 0;
+        }
+
+        return true;
+    }
+};
+
+} // namespace fair::mq
+
+#endif /* FAIR_MQ_SPLITTER_H */

fairmq/devices/runBenchmarkSampler.cxx

@@ -1,13 +1,13 @@
 /********************************************************************************
- * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <runFairMQDevice.h>
+#include <fairmq/devices/BenchmarkSampler.h>
-#include <devices/FairMQBenchmarkSampler.h>
+#include <fairmq/runDevice.h>
 
 namespace bpo = boost::program_options;
 
@@ -15,15 +15,16 @@ 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")
         ("multipart", bpo::value<bool>()->default_value(false), "Handle multipart payloads")
+        ("memset", bpo::value<bool>()->default_value(false), "Memset allocated buffers to 0")
         ("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")
+        ("msg-alignment", bpo::value<size_t>()->default_value(0), "Message alignment")
         ("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");
 }
 
-FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /* config */)
+std::unique_ptr<fair::mq::Device> getDevice(const fair::mq::ProgOptions& /* config */)
 {
-    return new FairMQBenchmarkSampler();
+    return std::make_unique<fair::mq::BenchmarkSampler>();
 }

fairmq/devices/runMerger.cxx

@@ -1,13 +1,13 @@
 /********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <runFairMQDevice.h>
+#include <fairmq/devices/Merger.h>
-#include <devices/FairMQMerger.h>
+#include <fairmq/runDevice.h>
 
 namespace bpo = boost::program_options;
 
@@ -19,7 +19,7 @@ void addCustomOptions(bpo::options_description& options)
         ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
-FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
+std::unique_ptr<fair::mq::Device> getDevice(const fair::mq::ProgOptions& /*config*/)
 {
-    return new FairMQMerger();
+    return std::make_unique<fair::mq::Merger>();
 }

fairmq/devices/runMultiplier.cxx

@@ -1,13 +1,13 @@
 /********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <runFairMQDevice.h>
+#include <fairmq/devices/Multiplier.h>
-#include <devices/FairMQMultiplier.h>
+#include <fairmq/runDevice.h>
 
 namespace bpo = boost::program_options;
 
@@ -19,7 +19,7 @@ void addCustomOptions(bpo::options_description& options)
         ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
-FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
+std::unique_ptr<fair::mq::Device> getDevice(const fair::mq::ProgOptions& /*config*/)
 {
-    return new FairMQMultiplier();
+    return std::make_unique<fair::mq::Multiplier>();
 }

fairmq/devices/runProxy.cxx

@@ -1,13 +1,13 @@
 /********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <runFairMQDevice.h>
+#include <fairmq/devices/Proxy.h>
-#include <devices/FairMQProxy.h>
+#include <fairmq/runDevice.h>
 
 namespace bpo = boost::program_options;
 
@@ -19,7 +19,7 @@ void addCustomOptions(bpo::options_description& options)
         ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
-FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
+std::unique_ptr<fair::mq::Device> getDevice(const fair::mq::ProgOptions& /*config*/)
 {
-    return new FairMQProxy();
+    return std::make_unique<fair::mq::Proxy>();
 }

fairmq/devices/runSink.cxx

@@ -1,13 +1,13 @@
 /********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <runFairMQDevice.h>
+#include <fairmq/devices/Sink.h>
-#include <devices/FairMQSink.h>
+#include <fairmq/runDevice.h>
 
 namespace bpo = boost::program_options;
 
@@ -15,11 +15,13 @@ void addCustomOptions(bpo::options_description& options)
 {
     options.add_options()
         ("in-channel", bpo::value<std::string>()->default_value("data"), "Name of the input channel")
+        ("out-filename", bpo::value<std::string>()->default_value(""), "Write incoming message buffers to the specified file")
+        ("max-file-size", bpo::value<uint64_t>()->default_value(2000000000), "Maximum file size for the file output (0 - unlimited)")
         ("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 fair::mq::ProgOptions& /*config*/)
+std::unique_ptr<fair::mq::Device> getDevice(const fair::mq::ProgOptions& /*config*/)
 {
-    return new FairMQSink();
+    return std::make_unique<fair::mq::Sink>();
 }

fairmq/devices/runSplitter.cxx

@@ -1,13 +1,13 @@
 /********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2014-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <runFairMQDevice.h>
+#include <fairmq/devices/Splitter.h>
-#include <devices/FairMQSplitter.h>
+#include <fairmq/runDevice.h>
 
 namespace bpo = boost::program_options;
 
@@ -19,7 +19,7 @@ void addCustomOptions(bpo::options_description& options)
         ("multipart", bpo::value<bool>()->default_value(true), "Handle multipart payloads");
 }
 
-FairMQDevicePtr getDevice(const fair::mq::ProgOptions& /*config*/)
+std::unique_ptr<fair::mq::Device> getDevice(const fair::mq::ProgOptions& /*config*/)
 {
-    return new FairMQSplitter();
+    return std::make_unique<fair::mq::Splitter>();
 }

fairmq/ofi/Context.cxx

@@ -7,7 +7,7 @@
  ********************************************************************************/
 
 #include <fairmq/ofi/Context.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
 #include <FairMQLogger.h>
 
 #include <asiofi/version.hpp>
@@ -22,11 +22,7 @@
 #include <string.h>
 #include <sys/socket.h>
 
-namespace fair
+namespace fair::mq::ofi
-{
-namespace mq
-{
-namespace ofi
 {
 
 using namespace std;
@@ -134,6 +130,4 @@ auto Context::MakeSendMessage(size_t size) -> MessagePtr
     return fSendFactory.CreateMessage(size);
 }
 
-} /* namespace ofi */
+} // namespace fair::mq::ofi
-} /* namespace mq */
-} /* namespace fair */

fairmq/ofi/Context.h

@@ -24,11 +24,7 @@
 #include <thread>
 #include <vector>
 
-namespace fair
+namespace fair::mq::ofi
-{
-namespace mq
-{
-namespace ofi
 {
 
 enum class ConnectionType : bool { Bind, Connect };
@@ -88,8 +84,6 @@ class Context
 
 struct ContextError : std::runtime_error { using std::runtime_error::runtime_error; };
 
-} /* namespace ofi */
+} // namespace fair::mq::ofi
-} /* namespace mq */
-} /* namespace fair */
 
 #endif /* FAIR_MQ_OFI_CONTEXT_H */

fairmq/ofi/ControlMessages.h

@@ -17,8 +17,8 @@
 #include <memory>
 #include <type_traits>
 
-namespace boost {
+namespace boost::asio
-namespace asio {
+{
 
 template<typename PodType>
 auto buffer(const PodType& obj) -> boost::asio::const_buffer
@@ -26,12 +26,10 @@ auto buffer(const PodType& obj) -> boost::asio::const_buffer
     return boost::asio::const_buffer(static_cast<const void*>(&obj), sizeof(PodType));
 }
 
-}   // namespace asio
+} // namespace boost::asio
-}   // namespace boost
 
-namespace fair {
+namespace fair::mq::ofi
-namespace mq {
+{
-namespace ofi {
 
 enum class ControlMessageType
 {
@@ -109,8 +107,6 @@ auto MakeControlMessage(Args&&... args) -> ControlMessage
     return ctrl;
 }
 
-}   // namespace ofi
+} // namespace fair::mq::ofi
-}   // namespace mq
-}   // namespace fair
 
 #endif /* FAIR_MQ_OFI_CONTROLMESSAGES_H */