DeviceRunner: Set log severity only if one was provided

Debian's libpmix-dev package installs everything below
/usr/lib/ARCH-TRIPLET/pmix2.
For some reasoning behind this,
see: https://bugs.debian.org/882033

CMake does not search there by default, so help it.

Also add myself to CONTRIBUTORS.

.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

@@ -31,28 +31,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_NANOMSG_TRANSPORT "Build nanomsg 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_OFI_TRANSPORT     "Build experimental OFI transport."
+fairmq_build_option(BUILD_SDK_COMMANDS  "Build the FairMQ SDK commands."
-                                             DEFAULT OFF REQUIRES "BUILD_FAIRMQ")
+                                         DEFAULT OFF)
-fairmq_build_option(BUILD_SDK_COMMANDS      "Build the FairMQ SDK commands."
+fairmq_build_option(BUILD_DDS_PLUGIN    "Build DDS plugin."
-                                             DEFAULT OFF)
+                                         DEFAULT OFF REQUIRES "BUILD_FAIRMQ;BUILD_SDK_COMMANDS")
-fairmq_build_option(BUILD_DDS_PLUGIN        "Build DDS 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_PMIX_PLUGIN       "Build PMIx plugin."
+fairmq_build_option(BUILD_EXAMPLES      "Build FairMQ examples."
-                                             DEFAULT OFF REQUIRES "BUILD_FAIRMQ;BUILD_SDK_COMMANDS")
+                                         DEFAULT ON  REQUIRES "BUILD_FAIRMQ")
-fairmq_build_option(BUILD_EXAMPLES          "Build FairMQ examples."
+fairmq_build_option(BUILD_SDK           "Build the FairMQ controller SDK."
-                                             DEFAULT ON  REQUIRES "BUILD_FAIRMQ")
+                                         DEFAULT OFF REQUIRES "BUILD_DDS_PLUGIN;BUILD_SDK_COMMANDS")
-fairmq_build_option(BUILD_SDK               "Build the FairMQ controller SDK."
+fairmq_build_option(BUILD_DOCS          "Build FairMQ documentation."
-                                             DEFAULT OFF REQUIRES "BUILD_DDS_PLUGIN;BUILD_SDK_COMMANDS")
+                                         DEFAULT OFF)
-fairmq_build_option(BUILD_DOCS              "Build FairMQ documentation."
+fairmq_build_option(FAST_BUILD          "Fast production build. Not recommended for development."
-                                             DEFAULT OFF)
+                                         DEFAULT OFF)
-fairmq_build_option(FAST_BUILD              "Fast production build. Not recommended for development."
+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)
 ################################################################################
 
 
@@ -65,11 +67,6 @@ set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
 set(THREADS_PREFER_PTHREAD_FLAG TRUE)
 find_package(Threads REQUIRED)
 
-if(BUILD_NANOMSG_TRANSPORT)
-  find_package2(PRIVATE nanomsg REQUIRED)
-  set(PROJECT_nanomsg_VERSION 1.1.3) # Once upstream releases 1.1.5, we should bump again and use version check
-endif()
-
 if(BUILD_OFI_TRANSPORT)
   find_package2(PRIVATE asiofi REQUIRED
     VERSION 0.3.1
@@ -79,12 +76,6 @@ if(BUILD_OFI_TRANSPORT)
   )
 endif()
 
-if(BUILD_NANOMSG_TRANSPORT)
-  find_package2(PRIVATE msgpack REQUIRED
-    VERSION 3.1.0
-  )
-endif()
-
 if(BUILD_SDK_COMMANDS)
   find_package2(PRIVATE Flatbuffers REQUIRED)
 endif()
@@ -105,7 +96,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)
@@ -157,10 +148,14 @@ 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)
-  find_package2(PRIVATE GTest VERSION 1.7.0)
+  if(USE_EXTERNAL_GTEST)
+    find_package2(PRIVATE GTest VERSION 1.7.0)
+  endif()
   if(NOT GTest_FOUND)
     build_bundled(GTest extern/googletest)
     find_package2(PRIVATE GTest REQUIRED)
@@ -215,9 +210,6 @@ endif()
 if(BUILD_PMIX_PLUGIN)
   list(APPEND PROJECT_PACKAGE_COMPONENTS pmix_plugin)
 endif()
-if(BUILD_NANOMSG_TRANSPORT)
-  list(APPEND PROJECT_PACKAGE_COMPONENTS nanomsg_transport)
-endif()
 if(BUILD_OFI_TRANSPORT)
   list(APPEND PROJECT_PACKAGE_COMPONENTS ofi_transport)
 endif()
@@ -320,16 +312,10 @@ if(PROJECT_PACKAGE_DEPENDENCIES)
       endif()
     elseif(${dep} STREQUAL GTest)
       get_filename_component(prefix ${GTEST_INCLUDE_DIRS}/.. ABSOLUTE)
-    elseif(${dep} STREQUAL msgpack)
-      get_target_property(msgpack_include msgpackc-cxx INTERFACE_INCLUDE_DIRECTORIES)
-      get_filename_component(prefix ${msgpack_include}/.. ABSOLUTE)
     elseif(${dep} STREQUAL asiofi)
       set(prefix ${asiofi_ROOT})
     elseif(${dep} STREQUAL OFI)
       get_filename_component(prefix ${${dep}_INCLUDE_DIRS}/.. ABSOLUTE)
-    elseif(${dep} STREQUAL nanomsg)
-      get_target_property(nn_include nanomsg INTERFACE_INCLUDE_DIRECTORIES)
-      get_filename_component(prefix ${nn_include}/.. ABSOLUTE)
     elseif(${dep} STREQUAL DDS)
       set(prefix "${DDS_INSTALL_PREFIX}")
     elseif(${dep} STREQUAL Boost)
@@ -378,12 +364,6 @@ else()
   set(tests_summary "${BRed} NO${CR}    (enable with ${BMagenta}-DBUILD_TESTING=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}tests${CR}              ${tests_summary}")
-if(BUILD_NANOMSG_TRANSPORT)
-  set(nn_summary "${BGreen}YES${CR}    (disable with ${BMagenta}-DBUILD_NANOMSG_TRANSPORT=OFF${CR})")
-else()
-  set(nn_summary "${BRed} NO${CR}    (default, enable with ${BMagenta}-DBUILD_NANOMSG_TRANSPORT=ON${CR})")
-endif()
-message(STATUS "  ${BWhite}nanomsg_transport${CR}  ${nn_summary}")
 if(BUILD_OFI_TRANSPORT)
   set(ofi_summary "${BGreen}YES${CR}    EXPERIMENTAL (requires C++14) (disable with ${BMagenta}-DBUILD_OFI_TRANSPORT=OFF${CR})")
 else()
@@ -451,4 +431,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

@@ -26,13 +26,13 @@ Set(configure_options "${configure_options};-DCTEST_USE_LAUNCHERS=${CTEST_USE_LA
 
 Set(configure_options "${configure_options};-DDISABLE_COLOR=ON")
 Set(configure_options "${configure_options};-DCMAKE_PREFIX_PATH=$ENV{SIMPATH}")
-Set(configure_options "${configure_options};-DBUILD_NANOMSG_TRANSPORT=ON")
 # Set(configure_options "${configure_options};-DBUILD_OFI_TRANSPORT=ON")
 Set(configure_options "${configure_options};-DBUILD_DDS_PLUGIN=ON")
 Set(configure_options "${configure_options};-DBUILD_SDK=ON")
 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(configure_options "${configure_options};-DBoost_NO_BOOST_CMAKE=ON")
 
 Set(EXTRA_FLAGS $ENV{EXTRA_FLAGS})
 If(EXTRA_FLAGS)

Jenkinsfile

@@ -8,11 +8,15 @@ def jobMatrix(String prefix, List specs, Closure callback) {
   def nodes = [:]
   for (spec in specs) {
     def label = specToLabel(spec)
+    def node_tag = label
+    if (spec.os =~ /macOS/) {
+      node_tag = spec.os
+    }
     def fairsoft = spec.fairsoft
     def os = spec.os
     def compiler = spec.compiler
     nodes["${prefix}/${label}"] = {
-      node(label) {
+      node(node_tag) {
         githubNotify(context: "${prefix}/${label}", description: 'Building ...', status: 'PENDING')
         try {
           deleteDir()
@@ -29,7 +33,7 @@ def jobMatrix(String prefix, List specs, Closure callback) {
               echo "module load compiler/gcc/9.1.0" >> Dart.cfg
             '''
           }
-          if (os =~ /MacOS/) {
+          if (os =~ /[Mm]acOS/) {
             sh "echo \"export EXTRA_FLAGS='-DCMAKE_CXX_COMPILER=clang++'\" >> Dart.cfg"
           } else {
             sh "echo \"export EXTRA_FLAGS='-DCMAKE_CXX_COMPILER=g++'\" >> Dart.cfg"
@@ -71,8 +75,7 @@ pipeline{
         script {
           def build_jobs = jobMatrix('build', [
             [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.15', arch: 'x86_64', compiler: 'AppleLLVM11.0.3', fairsoft: 'fairmq_dev'],
-            [os: 'MacOS10.14', arch: 'x86_64', compiler: 'AppleLLVM10.0.0', fairsoft: 'fairmq_dev'],
           ]) { spec, label ->
             sh './Dart.sh alfa_ci Dart.cfg'
           }

README.md

@@ -21,7 +21,7 @@ FairMQ is designed to help implementing large-scale data processing workflows ne
 The core of FairMQ provides an abstract asynchronous message passing API with scalability protocols
 inspired by [ZeroMQ](https://github.com/zeromq/libzmq) (e.g. PUSH/PULL, PUB/SUB).
 FairMQ provides multiple implementations for its API (so-called "transports",
-e.g. `zeromq`, `shmem`, `nanomsg`, and `ofi` (in development)) to cover a variety of use cases
+e.g. `zeromq`, `shmem` and `ofi` (in development)) to cover a variety of use cases
 (e.g. inter-thread, inter-process, inter-node communication) and machines (e.g. Ethernet, Infiniband).
 In addition to this core functionality FairMQ provides a framework for creating "devices" - actors which
 are communicating through message passing. FairMQ does not only allow the user to use different transport but also to mix them; i.e: A Device can communicate using different transport on different channels at the same time. Device execution is modelled as a simple state machine that
@@ -47,7 +47,7 @@ cmake --build fairmq_build --target install
 
 Please consult the [manpages of your CMake version](https://cmake.org/cmake/help/latest/manual/cmake.1.html) for more options.
 
-If dependencies are not installed in standard system directories, you can hint the installation location via `-DCMAKE_PREFIX_PATH=...` or per dependency via `-D{DEPENDENCY}_ROOT=...`. `{DEPENDENCY}` can be `GTEST`, `BOOST`, `FAIRLOGGER`, `ZEROMQ`, `MSGPACK`, `NANOMSG`, `OFI`, `PMIX`, `ASIO`, `ASIOFI` or `DDS` (`*_ROOT` variables can also be environment variables).
+If dependencies are not installed in standard system directories, you can hint the installation location via `-DCMAKE_PREFIX_PATH=...` or per dependency via `-D{DEPENDENCY}_ROOT=...`. `{DEPENDENCY}` can be `GTEST`, `BOOST`, `FAIRLOGGER`, `ZEROMQ`, `OFI`, `PMIX`, `ASIO`, `ASIOFI` or `DDS` (`*_ROOT` variables can also be environment variables).
 
 ## Usage
 
@@ -86,7 +86,7 @@ If your project shares a dependency with FairMQ or if you want to omit a certain
 Optionally, you can require certain FairMQ package components and a minimum version:
 
 ```cmake
-find_package(FairMQ 1.1.0 COMPONENTS nanomsg_transport dds_plugin)
+find_package(FairMQ 1.1.0 COMPONENTS dds_plugin)
 ```
 
 When building FairMQ, CMake will print a summary table of all available package components.
@@ -101,8 +101,6 @@ When building FairMQ, CMake will print a summary table of all available package
   * [Doxygen](http://www.doxygen.org/)
   * [FairLogger](https://github.com/FairRootGroup/FairLogger)
   * [GTest](https://github.com/google/googletest) (optionally bundled)
-  * [Msgpack](https://msgpack.org/index.html)
-  * [nanomsg](http://nanomsg.org/)
   * [PMIx](https://pmix.org/)
   * [ZeroMQ](http://zeromq.org/)
 
@@ -117,7 +115,6 @@ On command line:
   * `-DDISABLE_COLOR=ON` disables coloured console output.
   * `-DBUILD_TESTING=OFF` disables building of tests.
   * `-DBUILD_EXAMPLES=OFF` disables building of examples.
-  * `-DBUILD_NANOMSG_TRANSPORT=ON` enables building of nanomsg transport.
   * `-DBUILD_OFI_TRANSPORT=ON` enables building of the experimental OFI transport.
   * `-DBUILD_DDS_PLUGIN=ON` enables building of the DDS plugin.
   * `-DBUILD_PMIX_PLUGIN=ON` enables building of the PMIx plugin.
@@ -182,4 +179,3 @@ After the `find_package(FairMQ)` call the following CMake variables are defined:
        1. [DDS](docs/Plugins.md#731-dds)
        2. [PMIx](docs/Plugins.md#732-pmix)
 8. [Controller SDK](docs/SDK.md)
-

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()

docs/Device.md

@@ -18,7 +18,7 @@ Topology configuration is currently happening via setup scripts. This is very ru
 
 ## 1.2 Communication Patterns
 
-FairMQ devices communicate via the communication patterns offered by ZeroMQ (or nanomsg): PUSH-PULL, PUB-SUB, REQ-REP, PAIR, [more info here](http://api.zeromq.org/4-0:zmq-socket). Each transport may provide further patterns.
+FairMQ devices communicate via the communication patterns offered by ZeroMQ: PUSH-PULL, PUB-SUB, REQ-REP, PAIR, [more info here](http://api.zeromq.org/4-0:zmq-socket). Each transport may provide further patterns.
 
 ## 1.3 State Machine
 

docs/Transport.md

@@ -2,7 +2,7 @@
 
 # 2. Transport Interface
 
-The communication layer is available through the transport interface. Three interface implementations are currently available. Main implementation uses the [ZeroMQ](http://zeromq.org) library. Alternative implementation relies on the [nanomsg](http://nanomsg.org) library. Third transport implementation is using shared memory via boost::interprocess & ZeroMQ combination.
+The communication layer is available through the transport interface. Three interface implementations are currently available. Main implementation uses the [ZeroMQ](http://zeromq.org) library. Second transport implementation is using shared memory via boost::interprocess & ZeroMQ combination.
 
 Here is an overview to give an idea how the interface is implemented:
 
@@ -10,20 +10,20 @@ Here is an overview to give an idea how the interface is implemented:
 
 Currently, the transports have been tested to work with these communication patterns:
 
-|               | zeromq | nanomsg | shmem |
+|               | zeromq | shmem |
-| ------------- |--------| ------- | ----- |
+| ------------- |--------| ----- |
-| PAIR          | yes    | yes     | yes   |
+| PAIR          | yes    | yes   |
-| PUSH/PULL     | yes    | yes     | yes   |
+| PUSH/PULL     | yes    | yes   |
-| PUB/SUB       | yes    | yes     | no    |
+| PUB/SUB       | yes    | no    |
-| REQ/REP       | yes    | yes     | yes   |
+| REQ/REP       | yes    | yes   |
 
 The next table shows the supported address types for each transport implementation:
 
-|             | zeromq | nanomsg | shmem | comment                                       |
+|             | zeromq | shmem | comment                                       |
-| ----------- | ------ | ------- | ----- | --------------------------------------------- |
+| ----------- | ------ | ----- | --------------------------------------------- |
-| `inproc://` | yes    | yes     | yes   | in process: useful for unit testing           |
+| `inproc://` | yes    | yes   | in process: useful for unit testing           |
-| `ipc://`    | yes    | yes     | yes   | inter process comm: useful on single machine  |
+| `ipc://`    | yes    | yes   | inter process comm: useful on single machine  |
-| `tcp://`    | yes    | yes     | yes   | useful for any communication, local or remote |
+| `tcp://`    | yes    | yes   | useful for any communication, local or remote |
 
 ## 2.1 Message
 

examples/1-1/CMakeLists.txt

@@ -34,11 +34,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-1-1.sh.in ${CMAKE_CURRENT_BIN
 add_test(NAME Example.1-1.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-1-1.sh zeromq)
 set_tests_properties(Example.1-1.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received: ")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.1-1.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-1-1.sh nanomsg)
-  set_tests_properties(Example.1-1.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received: ")
-endif()
-
 add_test(NAME Example.1-1.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-1-1.sh shmem)
 set_tests_properties(Example.1-1.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received: ")
 

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

@@ -42,11 +42,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-1-n-1.sh.in ${CMAKE_CURRENT_B
 add_test(NAME Example.1-n-1.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-1-n-1.sh zeromq)
 set_tests_properties(Example.1-n-1.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received: ")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.1-n-1.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-1-n-1.sh nanomsg)
-  set_tests_properties(Example.1-n-1.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received: ")
-endif()
-
 add_test(NAME Example.1-n-1.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-1-n-1.sh shmem)
 set_tests_properties(Example.1-n-1.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received: ")
 

examples/CMakeLists.txt

@@ -13,9 +13,7 @@ add_subdirectory(copypush)
 add_subdirectory(dds)
 add_subdirectory(multipart)
 add_subdirectory(multiple-channels)
-if(BUILD_NANOMSG_TRANSPORT)
+add_subdirectory(multiple-transports)
-  add_subdirectory(multiple-transports)
-endif()
 add_subdirectory(n-m)
 add_subdirectory(qc)
 add_subdirectory(readout)

examples/README.md

@@ -32,7 +32,7 @@ This example demonstrates how to work with multiple channels and multiplex betwe
 
 ## Multiple Transports
 
-This examples shows how to combine different channel transports (zeromq/nanomsg/shmem) inside of one device and/or topology.
+This examples shows how to combine different channel transports (zeromq/shmem) inside of one device and/or topology.
 
 ## n-m
 

examples/builtin-devices/CMakeLists.txt

@@ -17,22 +17,12 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-builtin-devices.sh.in ${CMAKE
 add_test(NAME Example.BuiltinDevices.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh zeromq)
 set_tests_properties(Example.BuiltinDevices.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.BuiltinDevices.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh nanomsg)
-  set_tests_properties(Example.BuiltinDevices.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
-endif()
-
 add_test(NAME Example.BuiltinDevices.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh shmem)
 set_tests_properties(Example.BuiltinDevices.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
 
 add_test(NAME Example.BuiltinDevices.multipart.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh zeromq true 2)
 set_tests_properties(Example.BuiltinDevices.multipart.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.BuiltinDevices.multipart.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh nanomsg true 2)
-  set_tests_properties(Example.BuiltinDevices.multipart.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
-endif()
-
 add_test(NAME Example.BuiltinDevices.multipart.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-builtin-devices.sh shmem true 2)
 set_tests_properties(Example.BuiltinDevices.multipart.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Configured maximum number of iterations reached")
 

examples/copypush/CMakeLists.txt

@@ -35,11 +35,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-copypush.sh.in ${CMAKE_CURREN
 add_test(NAME Example.CopyPush.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-copypush.sh zeromq)
 set_tests_properties(Example.CopyPush.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received message: ")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.CopyPush.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-copypush.sh nanomsg)
-  set_tests_properties(Example.CopyPush.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received message: ")
-endif()
-
 add_test(NAME Example.CopyPush.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-copypush.sh shmem)
 set_tests_properties(Example.CopyPush.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received message: ")
 

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

@@ -34,11 +34,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-multipart.sh.in ${CMAKE_CURRE
 add_test(NAME Example.Multipart.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-multipart.sh zeromq)
 set_tests_properties(Example.Multipart.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received message with 7 parts")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.Multipart.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-multipart.sh nanomsg)
-  set_tests_properties(Example.Multipart.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received message with 7 parts")
-endif()
-
 add_test(NAME Example.Multipart.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-multipart.sh shmem)
 set_tests_properties(Example.Multipart.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received message with 7 parts")
 

examples/multiple-channels/CMakeLists.txt

@@ -39,11 +39,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-multiple-channels.sh.in ${CMA
 add_test(NAME Example.MultipleChannels.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-multiple-channels.sh zeromq)
 set_tests_properties(Example.MultipleChannels.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received messages from both sources.")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.MultipleChannels.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-multiple-channels.sh nanomsg)
-  set_tests_properties(Example.MultipleChannels.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received messages from both sources.")
-endif()
-
 # install
 
 install(

examples/multiple-transports/README.md

@@ -1,12 +1,12 @@
 Multiple Transports example
 ===========================
 
-This example demonstrates use of multiple transports (zeromq/nanomsg/shmem) within the same topology and/or device. It is a simple topology consisting of two samplers and a sink. The devices are connected via 3 channels:
+This example demonstrates use of multiple transports (zeromq/shmem) within the same topology and/or device. It is a simple topology consisting of two samplers and a sink. The devices are connected via 3 channels:
 
 ![Multiple Transports example](../../docs/images/example_multiple_transports.png?raw=true "Multiple Transports example")
 
 Each device has main transport that it uses. By default it is ZeroMQ, and can be overriden via the `--transport` cmd option. The device will initialize additional transports if any of the channels have them configured (e.g. as an option to `--channel-config`).
 
-In this example sampler1 and sink are started with `--transport shmem`, making shared memory their main transport, sampler2 with `--transport nanomsg`. Additionally, the ack channel is configured to use zeromq as its transport.
+In this example sampler1 and sink are started with `--transport shmem`, making shared memory their main transport, sampler2 with `--transport zeromq`. Additionally, the ack channel is configured to use zeromq as its transport.
 
 The main two things that a transport does is transfer of data and allocation of memory for the messages. By default, new messages are created via the main device transport. If a message has been created with one transport and is to be transferred with another, it has to be copied into a new message of the target transport. This happens automatically behind the scenes. To avoid this copy the device can create messages via `NewMessageFor(const string& channelName, int subChannelIndex, ...)` method, that creates the messages via the transport of the given channel (check sampler1 and sink for an example) or as the channel directly to create a message.

examples/multiple-transports/fairmq-start-ex-multiple-transports.sh.in

@@ -13,7 +13,7 @@ xterm -geometry 80x30+0+0 -hold -e @EX_BIN_DIR@/$SAMPLER1 &
 SAMPLER2="fairmq-ex-multiple-transports-sampler2"
 SAMPLER2+=" --id sampler2"
 SAMPLER2+=" --severity debug"
-SAMPLER2+=" --transport nanomsg"
+SAMPLER2+=" --transport shmem"
 SAMPLER2+=" --channel-config name=data2,type=push,method=bind,address=tcp://127.0.0.1:5556"
 xterm -geometry 80x30+0+450 -hold -e @EX_BIN_DIR@/$SAMPLER2 &
 
@@ -22,6 +22,6 @@ SINK+=" --id sink1"
 SINK+=" --severity debug"
 SINK+=" --transport shmem"
 SINK+=" --channel-config name=data1,type=pull,method=connect,address=tcp://127.0.0.1:5555"
-SINK+="                  name=data2,type=pull,method=connect,address=tcp://127.0.0.1:5556,transport=nanomsg"
+SINK+="                  name=data2,type=pull,method=connect,address=tcp://127.0.0.1:5556,transport=shmem"
 SINK+="                  name=ack,type=pub,method=connect,address=tcp://127.0.0.1:5557,transport=zeromq"
 xterm -geometry 80x30+500+225 -hold -e @EX_BIN_DIR@/$SINK &

examples/multiple-transports/test-ex-multiple-transports.sh.in

@@ -14,7 +14,7 @@ SINK+=" --max-iterations 1"
 SINK+=" --control static --color false"
 SINK+=" --transport shmem"
 SINK+=" --channel-config name=data1,type=pull,method=connect,address=tcp://127.0.0.1:5555"
-SINK+="                  name=data2,type=pull,method=connect,address=tcp://127.0.0.1:5556,transport=nanomsg"
+SINK+="                  name=data2,type=pull,method=connect,address=tcp://127.0.0.1:5556,transport=zeromq"
 SINK+="                  name=ack,type=pub,method=connect,address=tcp://127.0.0.1:5557,transport=zeromq"
 @CMAKE_CURRENT_BINARY_DIR@/$SINK &
 SINK_PID=$!
@@ -37,7 +37,7 @@ SAMPLER2+=" --session $SESSION"
 SAMPLER2+=" --verbosity veryhigh"
 SAMPLER2+=" --max-iterations 1"
 SAMPLER2+=" --control static --color false"
-SAMPLER2+=" --transport nanomsg"
+SAMPLER2+=" --transport zeromq"
 SAMPLER2+=" --channel-config name=data2,type=push,method=bind,address=tcp://127.0.0.1:5556"
 @CMAKE_CURRENT_BINARY_DIR@/$SAMPLER2 &
 SAMPLER2_PID=$!

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

@@ -37,10 +37,10 @@ class Readout : public FairMQDevice
         fRegion = FairMQUnmanagedRegionPtr(NewUnmanagedRegionFor("rb",
                                                                 0,
                                                                 10000000,
-                                                                [this](void* /*data*/, size_t /*size*/, void* /*hint*/) { // callback to be called when message buffers no longer needed by transport
+                                                                [this](const std::vector<fair::mq::RegionBlock>& blocks) { // callback to be called when message buffers no longer needed by transport
-                                                                    --fNumUnackedMsgs;
+                                                                    fNumUnackedMsgs -= blocks.size();
                                                                     if (fMaxIterations > 0) {
-                                                                        LOG(debug) << "Received ack";
+                                                                        LOG(debug) << "Received " << blocks.size() << " acks";
                                                                     }
                                                                 }
                                                                 ));

examples/region/CMakeLists.txt

@@ -32,15 +32,10 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fairmq-start-ex-region.sh.in ${CMAKE_
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-region.sh.in ${CMAKE_CURRENT_BINARY_DIR}/test-ex-region.sh)
 
 add_test(NAME Example.Region.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-region.sh zeromq)
-set_tests_properties(Example.Region.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received ack")
+set_tests_properties(Example.Region.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received [0-9*] acks")
-
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.Region.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-region.sh nanomsg)
-  set_tests_properties(Example.Region.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received ack")
-endif()
 
 add_test(NAME Example.Region.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-region.sh shmem)
-set_tests_properties(Example.Region.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received ack")
+set_tests_properties(Example.Region.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received [0-9*] acks")
 
 # install
 

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](void* /*data*/, size_t /*size*/, void* /*hint*/) { // callback to be called when message buffers no longer needed by transport
+                                                             [this](const std::vector<fair::mq::RegionBlock>& blocks) { // callback to be called when message buffers no longer needed by transport
-                                                                 --fNumUnackedMsgs;
+                                                                 lock_guard<mutex> lock(fMtx);
+                                                                 fNumUnackedMsgs -= blocks.size();
+
                                                                  if (fMaxIterations > 0) {
-                                                                     LOG(debug) << "Received ack";
+                                                                    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

@@ -35,11 +35,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test-ex-req-rep.sh.in ${CMAKE_CURRENT
 add_test(NAME Example.ReqRep.zeromq COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-req-rep.sh zeromq)
 set_tests_properties(Example.ReqRep.zeromq PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received reply from server: ")
 
-if(BUILD_NANOMSG_TRANSPORT)
-  add_test(NAME Example.ReqRep.nanomsg COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-req-rep.sh nanomsg)
-  set_tests_properties(Example.ReqRep.nanomsg PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received reply from server: ")
-endif()
-
 add_test(NAME Example.ReqRep.shmem COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test-ex-req-rep.sh shmem)
 set_tests_properties(Example.ReqRep.shmem PROPERTIES TIMEOUT "30" RUN_SERIAL true PASS_REGULAR_EXPRESSION "Received reply from server: ")
 

fairmq/CMakeLists.txt

@@ -170,15 +170,10 @@ if(BUILD_FAIRMQ)
     PluginManager.h
     PluginServices.h
     runFairMQDevice.h
+    shmem/Monitor.h
   )
 
   set(FAIRMQ_PRIVATE_HEADER_FILES
-    devices/FairMQBenchmarkSampler.h
-    devices/FairMQMerger.h
-    devices/FairMQMultiplier.h
-    devices/FairMQProxy.h
-    devices/FairMQSink.h
-    devices/FairMQSplitter.h
     plugins/Builtin.h
     plugins/config/Config.h
     plugins/Control.h
@@ -190,23 +185,14 @@ if(BUILD_FAIRMQ)
     shmem/Common.h
     shmem/Manager.h
     shmem/Region.h
-    zeromq/FairMQMessageZMQ.h
+    zeromq/Context.h
-    zeromq/FairMQPollerZMQ.h
+    zeromq/Message.h
-    zeromq/FairMQUnmanagedRegionZMQ.h
+    zeromq/Poller.h
-    zeromq/FairMQSocketZMQ.h
+    zeromq/UnmanagedRegion.h
-    zeromq/FairMQTransportFactoryZMQ.h
+    zeromq/Socket.h
+    zeromq/TransportFactory.h
   )
 
-  if(BUILD_NANOMSG_TRANSPORT)
-    set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
-      nanomsg/FairMQMessageNN.h
-      nanomsg/FairMQPollerNN.h
-      nanomsg/FairMQUnmanagedRegionNN.h
-      nanomsg/FairMQSocketNN.h
-      nanomsg/FairMQTransportFactoryNN.h
-    )
-  endif()
-
   if(BUILD_OFI_TRANSPORT)
     set(FAIRMQ_PRIVATE_HEADER_FILES ${FAIRMQ_PRIVATE_HEADER_FILES}
       ofi/Context.h
@@ -229,11 +215,6 @@ if(BUILD_FAIRMQ)
     FairMQPoller.cxx
     FairMQSocket.cxx
     FairMQTransportFactory.cxx
-    devices/FairMQBenchmarkSampler.cxx
-    devices/FairMQMerger.cxx
-    devices/FairMQMultiplier.cxx
-    devices/FairMQProxy.cxx
-    devices/FairMQSplitter.cxx
     Plugin.cxx
     PluginManager.cxx
     PluginServices.cxx
@@ -243,30 +224,10 @@ if(BUILD_FAIRMQ)
     SuboptParser.cxx
     plugins/config/Config.cxx
     plugins/Control.cxx
-    shmem/Message.cxx
-    shmem/Poller.cxx
-    shmem/Socket.cxx
-    shmem/TransportFactory.cxx
-    shmem/Manager.cxx
-    shmem/Region.cxx
-    zeromq/FairMQMessageZMQ.cxx
-    zeromq/FairMQPollerZMQ.cxx
-    zeromq/FairMQUnmanagedRegionZMQ.cxx
-    zeromq/FairMQSocketZMQ.cxx
-    zeromq/FairMQTransportFactoryZMQ.cxx
     MemoryResources.cxx
+    shmem/Monitor.cxx
   )
 
-  if(BUILD_NANOMSG_TRANSPORT)
-    set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
-      nanomsg/FairMQMessageNN.cxx
-      nanomsg/FairMQPollerNN.cxx
-      nanomsg/FairMQUnmanagedRegionNN.cxx
-      nanomsg/FairMQSocketNN.cxx
-      nanomsg/FairMQTransportFactoryNN.cxx
-    )
-  endif()
-
   if(BUILD_OFI_TRANSPORT)
     set(FAIRMQ_SOURCE_FILES ${FAIRMQ_SOURCE_FILES}
       ofi/Context.cxx
@@ -307,8 +268,8 @@ if(BUILD_FAIRMQ)
   # preprocessor definitions #
   ############################
   target_compile_definitions(${_target} PUBLIC BOOST_ERROR_CODE_HEADER_ONLY)
-  if(BUILD_NANOMSG_TRANSPORT)
+  if(FAIRMQ_DEBUG_MODE)
-    target_compile_definitions(${_target} PRIVATE BUILD_NANOMSG_TRANSPORT)
+    target_compile_definitions(${_target} PUBLIC FAIRMQ_DEBUG_MODE)
   endif()
   if(BUILD_OFI_TRANSPORT)
     target_compile_definitions(${_target} PRIVATE BUILD_OFI_TRANSPORT)
@@ -330,16 +291,13 @@ if(BUILD_FAIRMQ)
   ##################
   # link libraries #
   ##################
-  if(BUILD_NANOMSG_TRANSPORT)
-    set(NANOMSG_DEPS nanomsg msgpackc-cxx)
-  endif()
   if(BUILD_OFI_TRANSPORT)
     set(OFI_DEPS
       asiofi::asiofi
       Boost::container
     )
   endif()
-  set(optional_deps ${NANOMSG_DEPS} ${OFI_DEPS})
+  set(optional_deps ${OFI_DEPS})
   if(optional_deps)
     list(REMOVE_DUPLICATES optional_deps)
   endif()
@@ -362,7 +320,7 @@ if(BUILD_FAIRMQ)
 
     PRIVATE # only libFairMQ links against private dependencies
     libzmq
-    ${NANOMSG_DEPS}
+    PicoSHA2
     ${OFI_DEPS}
   )
   set_target_properties(${_target} PROPERTIES
@@ -409,12 +367,17 @@ if(BUILD_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}>

fairmq/DeviceRunner.cxx

@@ -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,9 @@ bool DeviceRunner::HandleGeneralOptions(const fair::mq::ProgOptions& config, boo
             fair::Logger::SetConsoleSeverity("nolog");
         } else {
             fair::Logger::SetConsoleColor(color);
-            fair::Logger::SetConsoleSeverity(severity);
+            if (severity != "") {
+                fair::Logger::SetConsoleSeverity(severity);
+            }
         }
 
         if (printLogo) {
@@ -150,8 +156,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

@@ -13,7 +13,6 @@
 #include <fairmq/PluginManager.h>
 #include <fairmq/ProgOptions.h>
 #include <FairMQDevice.h>
-#include <FairMQLogger.h>
 
 #include <functional>
 #include <memory>

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", "nanomsg" or "shmem")
+    /// Get channel transport name ("default", "zeromq" or "shmem")
-    /// @return Returns channel transport name (e.g. "default", "zeromq", "nanomsg" 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", "nanomsg" 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,13 +250,13 @@ 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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
     int Send(FairMQMessagePtr& msg, int sndTimeoutInMs = -1)
     {
         CheckSendCompatibility(msg);
@@ -262,7 +266,7 @@ 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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
     int Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs = -1)
     {
         CheckReceiveCompatibility(msg);
@@ -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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::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)
@@ -335,14 +336,10 @@ class FairMQChannel
         return Transport()->NewStaticMessage(data);
     }
 
-    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0)
+    template<typename... Args>
+    FairMQUnmanagedRegionPtr NewUnmanagedRegion(Args&&... args)
     {
-        return Transport()->CreateUnmanagedRegion(size, callback, path, flags);
+        return Transport()->CreateUnmanagedRegion(std::forward<Args>(args)...);
-    }
-
-    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size, const int64_t userFlags, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0)
-    {
-        return Transport()->CreateUnmanagedRegion(size, userFlags, callback, path, flags);
     }
 
     static constexpr fair::mq::Transport DefaultTransportType = fair::mq::Transport::DEFAULT;
@@ -380,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)
     {
@@ -443,8 +436,6 @@ class FairMQChannel
         fTransportFactory = factory;
         fTransportType = factory->GetType();
     }
-
-    auto SetModified(const bool modified) -> void;
 };
 
 #endif /* FAIRMQCHANNEL_H_ */

fairmq/FairMQDevice.cxx

@@ -390,7 +390,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 {

fairmq/FairMQDevice.h

@@ -26,7 +26,6 @@
 #include <algorithm> // find
 #include <string>
 #include <chrono>
-#include <iostream>
 #include <unordered_map>
 #include <functional>
 #include <stdexcept>
@@ -129,7 +128,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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
     int Send(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
     {
         return GetChannel(channel, index).Send(msg, sndTimeoutInMs);
@@ -140,7 +139,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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
     int Receive(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
     {
         return GetChannel(channel, index).Receive(msg, rcvTimeoutInMs);
@@ -151,7 +150,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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::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 +161,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, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::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);
@@ -217,45 +216,17 @@ class FairMQDevice
     }
 
     // creates unamanaged region with the default device transport
-    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size,
+    template<typename... Args>
-                                                FairMQRegionCallback callback = nullptr,
+    FairMQUnmanagedRegionPtr NewUnmanagedRegion(Args&&... args)
-                                                const std::string& path = "",
-                                                int flags = 0)
     {
-        return Transport()->CreateUnmanagedRegion(size, callback, path, flags);
+        return Transport()->CreateUnmanagedRegion(std::forward<Args>(args)...);
-    }
-
-    // creates unamanaged region with the default device transport
-    FairMQUnmanagedRegionPtr NewUnmanagedRegion(const size_t size,
-                                                const int64_t userFlags,
-                                                FairMQRegionCallback callback = nullptr,
-                                                const std::string& path = "",
-                                                int flags = 0)
-    {
-        return Transport()->CreateUnmanagedRegion(size, userFlags, callback, path, flags);
     }
 
     // creates unmanaged region with the transport of the specified channel
-    FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel,
+    template<typename... Args>
-                                                   int index,
+    FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel, int index, Args&&... args)
-                                                   const size_t size,
-                                                   FairMQRegionCallback callback = nullptr,
-                                                   const std::string& path = "",
-                                                   int flags = 0)
     {
-        return GetChannel(channel, index).NewUnmanagedRegion(size, callback, path, flags);
+        return GetChannel(channel, index).NewUnmanagedRegion(std::forward<Args>(args)...);
-    }
-
-    // creates unmanaged region with the transport of the specified channel
-    FairMQUnmanagedRegionPtr NewUnmanagedRegionFor(const std::string& channel,
-                                                   int index,
-                                                   const size_t size,
-                                                   const int64_t userFlags,
-                                                   FairMQRegionCallback callback = nullptr,
-                                                   const std::string& path = "",
-                                                   int flags = 0)
-    {
-        return GetChannel(channel, index).NewUnmanagedRegion(size, userFlags, callback, path, flags);
     }
 
     template<typename ...Ts>
@@ -302,7 +273,7 @@ class FairMQDevice
     }
 
     /// Adds a transport to the device if it doesn't exist
-    /// @param transport  Transport string ("zeromq"/"nanomsg"/"shmem")
+    /// @param transport  Transport string ("zeromq"/"shmem")
     std::shared_ptr<FairMQTransportFactory> AddTransport(const fair::mq::Transport transport);
 
     /// Assigns config to the device
@@ -391,10 +362,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;
             }
         }
     }
@@ -417,7 +388,7 @@ class FairMQDevice
     int GetInitTimeoutInS() const { return fConfig->GetProperty<int>("init-timeout", DefaultInitTimeout); }
 
     /// Sets the default transport for the device
-    /// @param transport  Transport string ("zeromq"/"nanomsg"/"shmem")
+    /// @param transport  Transport string ("zeromq"/"shmem")
     void SetTransport(const std::string& transport) { fConfig->SetProperty("transport", transport); }
     /// Gets the default transport name
     std::string GetTransportName() const { return fConfig->GetProperty<std::string>("transport", DefaultTransportName); }

fairmq/FairMQMessage.h

@@ -11,17 +11,33 @@
 
 #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 mq
+{
+
+struct Alignment
+{
+    size_t alignment;
+    explicit operator size_t() const { return alignment; }
+};
+
+} /* namespace mq */
+} /* namespace fair */
+
 class FairMQMessage
 {
   public:
     FairMQMessage() = default;
-    FairMQMessage(FairMQTransportFactory* factory):fTransport{factory} {}
+    FairMQMessage(FairMQTransportFactory* factory) : fTransport(factory) {}
+
     virtual void Rebuild() = 0;
     virtual void Rebuild(const size_t size) = 0;
     virtual void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) = 0;
@@ -33,7 +49,7 @@ class FairMQMessage
 
     virtual fair::mq::Transport GetType() const = 0;
     FairMQTransportFactory* GetTransport() { return fTransport; }
-    //void SetTransport(FairMQTransportFactory* transport) { fTransport = transport; }
+    void SetTransport(FairMQTransportFactory* transport) { fTransport = transport; }
 
     virtual void Copy(const FairMQMessage& msg) = 0;
 
@@ -53,6 +69,7 @@ namespace mq
 using Message = FairMQMessage;
 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 */

fairmq/FairMQSocket.h

@@ -9,18 +9,36 @@
 #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
+{
+namespace mq
+{
+
+enum class TransferResult : int
+{
+    error = -1,
+    timeout = -2,
+    interrupted = -3
+};
+
+} // namespace mq
+} // namespace fair
+
 class FairMQSocket
 {
   public:
     FairMQSocket() {}
-    FairMQSocket(FairMQTransportFactory* fac): fTransport(fac) {}
+    FairMQSocket(FairMQTransportFactory* fac) : fTransport(fac) {}
 
     virtual std::string GetId() const = 0;
 
@@ -37,6 +55,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;
@@ -54,7 +76,7 @@ class FairMQSocket
     virtual unsigned long GetMessagesRx() const = 0;
 
     FairMQTransportFactory* GetTransport() { return fTransport; }
-    void SetTransport(FairMQTransportFactory* transport) { fTransport=transport; }
+    void SetTransport(FairMQTransportFactory* transport) { fTransport = transport; }
 
     virtual ~FairMQSocket() {};
 

fairmq/FairMQTransportFactory.cxx

@@ -8,15 +8,15 @@
 
 #include <FairMQTransportFactory.h>
 #include <fairmq/shmem/TransportFactory.h>
-#include <zeromq/FairMQTransportFactoryZMQ.h>
+#include <fairmq/zeromq/TransportFactory.h>
-#ifdef BUILD_NANOMSG_TRANSPORT
-#include <nanomsg/FairMQTransportFactoryNN.h>
-#endif /* BUILD_NANOMSG_TRANSPORT */
 #ifdef BUILD_OFI_TRANSPORT
 #include <fairmq/ofi/TransportFactory.h>
 #endif
 #include <FairMQLogger.h>
-#include <fairmq/tools/Unique.h>
+#include <fairmq/Tools.h>
+
+#include <fairlogger/Logger.h>
+
 #include <memory>
 #include <string>
 
@@ -39,15 +39,10 @@ auto FairMQTransportFactory::CreateTransportFactory(const string& type,
     }
 
     if (type == "zeromq") {
-        return make_shared<FairMQTransportFactoryZMQ>(finalId, config);
+        return make_shared<fair::mq::zmq::TransportFactory>(finalId, config);
     } else if (type == "shmem") {
         return make_shared<fair::mq::shmem::TransportFactory>(finalId, config);
     }
-#ifdef BUILD_NANOMSG_TRANSPORT
-    else if (type == "nanomsg") {
-        return make_shared<FairMQTransportFactoryNN>(finalId, config);
-    }
-#endif /* BUILD_NANOMSG_TRANSPORT */
 #ifdef BUILD_OFI_TRANSPORT
     else if (type == "ofi") {
         return make_shared<fair::mq::ofi::TransportFactory>(finalId, config);
@@ -57,15 +52,12 @@ auto FairMQTransportFactory::CreateTransportFactory(const string& type,
         LOG(error) << "Unavailable transport requested: "
                    << "\"" << type << "\""
                    << ". Available are: "
-                   << "\"zeromq\""
+                   << "\"zeromq\","
                    << "\"shmem\""
-#ifdef BUILD_NANOMSG_TRANSPORT
-                   << ", \"nanomsg\""
-#endif /* BUILD_NANOMSG_TRANSPORT */
 #ifdef BUILD_OFI_TRANSPORT
                    << ", and \"ofi\""
 #endif /* BUILD_OFI_TRANSPORT */
                    << ". Exiting.";
-        exit(EXIT_FAILURE);
+        throw fair::mq::TransportFactoryError(fair::mq::tools::ToString("Unavailable transport requested: ", type));
     }
 }

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>
@@ -18,7 +17,7 @@
 #include <fairmq/Transports.h>
 
 #include <string>
-#include <memory>
+#include <memory> // shared_ptr
 #include <vector>
 #include <unordered_map>
 #include <stdexcept>
@@ -47,13 +46,22 @@ class FairMQTransportFactory
     fair::mq::ChannelResource* GetMemoryResource() { return &fMemoryResource; }
     operator fair::mq::ChannelResource*() { return &fMemoryResource; }
 
-    /// @brief Create empty FairMQMessage
+    /// @brief Create empty FairMQMessage (for receiving)
     /// @return pointer to FairMQMessage
     virtual FairMQMessagePtr CreateMessage() = 0;
+    /// @brief Create empty FairMQMessage (for receiving), align received buffer to specified alignment
+    /// @param alignment alignment to align received buffer to
+    /// @return pointer to FairMQMessage
+    virtual FairMQMessagePtr CreateMessage(fair::mq::Alignment alignment) = 0;
     /// @brief Create new FairMQMessage of specified size
     /// @param size message size
     /// @return pointer to FairMQMessage
     virtual FairMQMessagePtr CreateMessage(const size_t size) = 0;
+    /// @brief Create new FairMQMessage of specified size and alignment
+    /// @param size message size
+    /// @param alignment message alignment
+    /// @return pointer to FairMQMessage
+    virtual FairMQMessagePtr CreateMessage(const size_t size, fair::mq::Alignment alignment) = 0;
     /// @brief Create new FairMQMessage with user provided buffer and size
     /// @param data pointer to user provided buffer
     /// @param size size of the user provided buffer
@@ -84,7 +92,8 @@ class FairMQTransportFactory
     /// @param path optional parameter to pass to the underlying transport
     /// @param flags optional parameter to pass to the underlying transport
     /// @return pointer to UnmanagedRegion
-    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0) const = 0;
+    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0) = 0;
+    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionBulkCallback callback = nullptr, const std::string& path = "", int flags = 0) = 0;
     /// @brief Create new UnmanagedRegion
     /// @param size size of the region
     /// @param userFlags flags to be stored with the region, have no effect on the transport, but can be retrieved from the region by the user
@@ -92,11 +101,15 @@ class FairMQTransportFactory
     /// @param path optional parameter to pass to the underlying transport
     /// @param flags optional parameter to pass to the underlying transport
     /// @return pointer to UnmanagedRegion
-    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, const int64_t userFlags, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0) const = 0;
+    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, const int64_t userFlags, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0) = 0;
+    virtual FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, const int64_t userFlags, FairMQRegionBulkCallback callback = nullptr, const std::string& path = "", int flags = 0) = 0;
 
     /// @brief Subscribe to region events (creation, destruction, ...)
     /// @param callback the callback that is called when a region event occurs
     virtual void SubscribeToRegionEvents(FairMQRegionEventCallback callback) = 0;
+    /// @brief Check if there is an active subscription to region events
+    /// @return true/false
+    virtual bool SubscribedToRegionEvents() = 0;
     /// @brief Unsubscribe from region events
     virtual void UnsubscribeFromRegionEvents() = 0;
 

fairmq/FairMQUnmanagedRegion.h

@@ -10,17 +10,42 @@
 #define FAIRMQUNMANAGEDREGION_H_
 
 #include <cstddef> // size_t
+#include <cstdint> // uint32_t
 #include <memory> // std::unique_ptr
 #include <functional> // std::function
 #include <ostream> // std::ostream
+#include <vector>
+
+class FairMQTransportFactory;
 
 enum class FairMQRegionEvent : int
 {
     created,
-    destroyed
+    destroyed,
+    local_only
 };
 
-struct FairMQRegionInfo {
+struct FairMQRegionInfo
+{
+    FairMQRegionInfo()
+        : managed(true)
+        , id(0)
+        , ptr(nullptr)
+        , size(0)
+        , flags(0)
+        , event(FairMQRegionEvent::created)
+    {}
+
+    FairMQRegionInfo(bool _managed, uint64_t _id, void* _ptr, size_t _size, int64_t _flags, FairMQRegionEvent _event)
+        : managed(_managed)
+        , id(_id)
+        , ptr(_ptr)
+        , size(_size)
+        , flags(_flags)
+        , 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
@@ -28,26 +53,54 @@ struct FairMQRegionInfo {
     FairMQRegionEvent event;
 };
 
+struct FairMQRegionBlock {
+    void* ptr;
+    size_t size;
+    void* hint;
+
+    FairMQRegionBlock(void* p, size_t s, void* h)
+        : ptr(p), size(s), hint(h)
+    {}
+};
+
 using FairMQRegionCallback = std::function<void(void*, size_t, void*)>;
+using FairMQRegionBulkCallback = std::function<void(const std::vector<FairMQRegionBlock>&)>;
 using FairMQRegionEventCallback = std::function<void(FairMQRegionInfo)>;
 
 class FairMQUnmanagedRegion
 {
   public:
+    FairMQUnmanagedRegion() {}
+    FairMQUnmanagedRegion(FairMQTransportFactory* factory) : fTransport(factory) {}
+
     virtual void* GetData() const = 0;
     virtual size_t GetSize() 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; }
 
     virtual ~FairMQUnmanagedRegion() {};
+
+  private:
+    FairMQTransportFactory* fTransport{nullptr};
 };
 
 using FairMQUnmanagedRegionPtr = std::unique_ptr<FairMQUnmanagedRegion>;
 
 inline std::ostream& operator<<(std::ostream& os, const FairMQRegionEvent& event)
 {
-    if (event == FairMQRegionEvent::created) {
+    switch (event) {
-        return os << "created";
+        case FairMQRegionEvent::created:
-    } else {
+            return os << "created";
-        return os << "destroyed";
+        case FairMQRegionEvent::destroyed:
+            return os << "destroyed";
+        case FairMQRegionEvent::local_only:
+            return os << "local_only";
+        default:
+            return os << "unrecognized event";
     }
 }
 
@@ -57,9 +110,11 @@ namespace mq
 {
 
 using RegionCallback = FairMQRegionCallback;
+using RegionBulkCallback = FairMQRegionBulkCallback;
 using RegionEventCallback = FairMQRegionEventCallback;
 using RegionEvent = FairMQRegionEvent;
 using RegionInfo = FairMQRegionInfo;
+using RegionBlock = FairMQRegionBlock;
 using UnmanagedRegion = FairMQUnmanagedRegion;
 using UnmanagedRegionPtr = FairMQUnmanagedRegionPtr;
 

fairmq/JSONParser.cxx

@@ -12,16 +12,19 @@
  * 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/CppSTL.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;

fairmq/JSONParser.h

@@ -15,15 +15,11 @@
 #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
 {

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

@@ -18,11 +18,12 @@
 #include <fairmq/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 {

fairmq/PluginServices.h

@@ -17,13 +17,14 @@
 #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
 {

fairmq/ProgOptions.cxx

@@ -79,7 +79,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)")
@@ -117,16 +117,24 @@ void ProgOptions::ParseAll(const int argc, char const* const* argv, bool allowUn
     // clear the container because it was filled with default values and subsequent calls to store() do not overwrite the existing values
     fVarMap.clear();
 
-    if (allowUnregistered) {
-        po::command_line_parser parser(argc, argv);
-        parser.options(fAllOptions).allow_unregistered();
-        po::parsed_options parsed = parser.run();
-        fUnregisteredOptions = po::collect_unrecognized(parsed.options, po::include_positional);
 
-        po::store(parsed, fVarMap);
+    po::command_line_parser parser(argc, argv);
-    } else {
+
-        po::store(po::parse_command_line(argc, argv, fAllOptions), fVarMap);
+    parser.options(fAllOptions);
+
+    if (allowUnregistered) {
+        parser.allow_unregistered();
     }
+
+    using namespace po::command_line_style;
+    style_t style = style_t(allow_short | short_allow_adjacent | short_allow_next | allow_long | long_allow_adjacent | long_allow_next | allow_sticky | allow_dash_for_short);
+    parser.style(style);
+
+    po::parsed_options parsed = parser.run();
+
+    fUnregisteredOptions = po::collect_unrecognized(parsed.options, po::include_positional);
+
+    po::store(parsed, fVarMap);
 }
 
 void ProgOptions::Notify()

fairmq/Properties.cxx

@@ -76,9 +76,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 +94,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 +114,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 +132,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)); } },

fairmq/Properties.h

@@ -16,6 +16,7 @@
 #include <functional>
 #include <map>
 #include <unordered_map>
+#include <stdexcept>
 #include <string>
 #include <typeindex>
 #include <typeinfo>

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

fairmq/StateMachine.h

@@ -11,8 +11,6 @@
 
 #include <fairmq/States.h>
 
-#include <fairlogger/Logger.h>
-
 #include <string>
 #include <memory>
 #include <functional>

fairmq/States.cxx

@@ -18,9 +18,10 @@ namespace fair
 namespace mq
 {
 
-array<string, 15> stateNames =
+array<string, 16> stateNames =
 {
     {
+        "UNDEFINED",
         "OK",
         "ERROR",
         "IDLE",
@@ -41,6 +42,7 @@ array<string, 15> stateNames =
 
 unordered_map<string, State> states =
 {
+    { "UNDEFINED",           State::Undefined },
     { "OK",                  State::Ok },
     { "ERROR",               State::Error },
     { "IDLE",                State::Idle },

fairmq/States.h

@@ -20,6 +20,7 @@ namespace mq
 
 enum class State : int
 {
+    Undefined = 0,
     Ok,
     Error,
     Idle,
@@ -39,7 +40,7 @@ enum class State : int
 
 enum class Transition : int
 {
-    Auto,
+    Auto = 0,
     InitDevice,
     CompleteInit,
     Bind,

fairmq/SuboptParser.cxx

@@ -12,9 +12,12 @@
 /// @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 <cstring>
+
 #include <utility> // make_pair
 
 using boost::property_tree::ptree;

fairmq/SuboptParser.h

@@ -14,7 +14,7 @@
 #ifndef FAIR_MQ_SUBOPTPARSER_H
 #define FAIR_MQ_SUBOPTPARSER_H
 
-#include <fairmq/JSONParser.h>
+#include <fairmq/Properties.h>
 
 #include <vector>
 #include <string>

fairmq/Transports.h

@@ -10,8 +10,10 @@
 #define FAIR_MQ_TRANSPORTS_H
 
 #include <fairmq/tools/CppSTL.h>
+#include <fairmq/tools/Strings.h>
 
 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <unordered_map>
 
@@ -24,11 +26,12 @@ enum class Transport
 {
     DEFAULT,
     ZMQ,
-    NN,
     SHM,
     OFI
 };
 
+struct TransportError : std::runtime_error { using std::runtime_error::runtime_error; };
+
 } /* namespace mq */
 } /* namespace fair */
 
@@ -48,7 +51,6 @@ namespace mq
 static std::unordered_map<std::string, Transport> TransportTypes {
     { "default", Transport::DEFAULT },
     { "zeromq", Transport::ZMQ },
-    { "nanomsg", Transport::NN },
     { "shmem", Transport::SHM },
     { "ofi", Transport::OFI }
 };
@@ -56,11 +58,22 @@ static std::unordered_map<std::string, Transport> TransportTypes {
 static std::unordered_map<Transport, std::string> TransportNames {
     { Transport::DEFAULT, "default" },
     { Transport::ZMQ, "zeromq" },
-    { Transport::NN, "nanomsg" },
     { Transport::SHM, "shmem" },
     { Transport::OFI, "ofi" }
 };
 
+inline std::string TransportName(Transport transport)
+{
+    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 mq */
 } /* namespace fair */
 

fairmq/devices/FairMQBenchmarkSampler.cxx

@@ -1,100 +0,0 @@
-/********************************************************************************
- * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-
-#include "FairMQBenchmarkSampler.h"
-
-#include "tools/RateLimit.h"
-#include "../FairMQLogger.h"
-
-#include <chrono>
-
-using namespace std;
-
-FairMQBenchmarkSampler::FairMQBenchmarkSampler()
-    : fMultipart(false)
-    , fNumParts(1)
-    , fMsgSize(10000)
-    , fMsgRate(0)
-    , fNumIterations(0)
-    , fMaxIterations(0)
-    , fOutChannelName()
-{
-}
-
-void FairMQBenchmarkSampler::InitTask()
-{
-    fMultipart = fConfig->GetProperty<bool>("multipart");
-    fNumParts = fConfig->GetProperty<size_t>("num-parts");
-    fMsgSize = fConfig->GetProperty<size_t>("msg-size");
-    fMsgRate = fConfig->GetProperty<float>("msg-rate");
-    fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
-    fOutChannelName = fConfig->GetProperty<string>("out-channel");
-}
-
-void FairMQBenchmarkSampler::Run()
-{
-    // 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 = chrono::high_resolution_clock::now();
-
-    fair::mq::tools::RateLimiter rateLimiter(fMsgRate);
-
-    while (!NewStatePending())
-    {
-        if (fMultipart)
-        {
-            FairMQParts parts;
-
-            for (size_t i = 0; i < fNumParts; ++i)
-            {
-                parts.AddPart(dataOutChannel.NewMessage(fMsgSize));
-            }
-
-            if (dataOutChannel.Send(parts) >= 0)
-            {
-                if (fMaxIterations > 0)
-                {
-                    if (fNumIterations >= fMaxIterations)
-                    {
-                        break;
-                    }
-                }
-                ++fNumIterations;
-            }
-        }
-        else
-        {
-            FairMQMessagePtr msg(dataOutChannel.NewMessage(fMsgSize));
-
-            if (dataOutChannel.Send(msg) >= 0)
-            {
-                if (fMaxIterations > 0)
-                {
-                    if (fNumIterations >= fMaxIterations)
-                    {
-                        break;
-                    }
-                }
-                ++fNumIterations;
-            }
-        }
-
-        if (fMsgRate > 0)
-        {
-            rateLimiter.maybe_sleep();
-        }
-    }
-
-    auto tEnd = chrono::high_resolution_clock::now();
-
-    LOG(info) << "Done " << fNumIterations << " iterations in " << chrono::duration<double, milli>(tEnd - tStart).count() << "ms.";
-}

fairmq/devices/FairMQBenchmarkSampler.h

@@ -9,13 +9,16 @@
 #ifndef FAIRMQBENCHMARKSAMPLER_H_
 #define FAIRMQBENCHMARKSAMPLER_H_
 
-#include <string>
+#include "../FairMQLogger.h"
-#include <atomic>
-#include <cstddef> // size_t
-#include <cstdint> // uint64_t
-
-
 #include "FairMQDevice.h"
+#include "tools/RateLimit.h"
+
+#include <atomic>
+#include <chrono>
+#include <cstddef>   // size_t
+#include <cstdint>   // uint64_t
+#include <cstring>   // memset
+#include <string>
 
 /**
  * Sampler to generate traffic for benchmarking.
@@ -24,21 +27,98 @@
 class FairMQBenchmarkSampler : public FairMQDevice
 {
   public:
-    FairMQBenchmarkSampler();
+    FairMQBenchmarkSampler()
+        : fMultipart(false)
+        , fMemSet(false)
+        , fNumParts(1)
+        , fMsgSize(10000)
+        , fMsgAlignment(0)
+        , fMsgRate(0)
+        , fNumIterations(0)
+        , fMaxIterations(0)
+        , fOutChannelName()
+    {}
+
+    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");
+    }
+
+    void Run() override
+    {
+        // store the channel reference to avoid traversing the map on every loop iteration
+        FairMQChannel& dataOutChannel = fChannels.at(fOutChannelName).at(0);
+
+        LOG(info) << "Starting the benchmark with message size of " << fMsgSize << " and " << fMaxIterations << " iterations.";
+        auto tStart = std::chrono::high_resolution_clock::now();
+
+        fair::mq::tools::RateLimiter rateLimiter(fMsgRate);
+
+        while (!NewStatePending()) {
+            if (fMultipart) {
+                FairMQParts parts;
+
+                for (size_t i = 0; i < fNumParts; ++i) {
+                    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) {
+                    if (fMaxIterations > 0) {
+                        if (fNumIterations >= fMaxIterations) {
+                            break;
+                        }
+                    }
+                    ++fNumIterations;
+                }
+            } else {
+                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) {
+                        if (fNumIterations >= fMaxIterations) {
+                            break;
+                        }
+                    }
+                    ++fNumIterations;
+                }
+            }
+
+            if (fMsgRate > 0) {
+                rateLimiter.maybe_sleep();
+            }
+        }
+
+        auto tEnd = std::chrono::high_resolution_clock::now();
+
+        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;
+    size_t fMsgAlignment;
     std::atomic<int> fMsgCounter;
     float fMsgRate;
     uint64_t fNumIterations;
     uint64_t fMaxIterations;
     std::string fOutChannelName;
-
-    virtual void InitTask() override;
-    virtual void Run() override;
 };
 
 #endif /* FAIRMQBENCHMARKSAMPLER_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

@@ -16,23 +16,100 @@
 #define FAIRMQMERGER_H_
 
 #include "FairMQDevice.h"
+#include "../FairMQPoller.h"
+#include "../FairMQLogger.h"
 
 #include <string>
+#include <vector>
 
 class FairMQMerger : public FairMQDevice
 {
   public:
-    FairMQMerger();
+    FairMQMerger()
-    virtual ~FairMQMerger();
+        : fMultipart(true)
+        , fInChannelName("data-in")
+        , fOutChannelName("data-out")
+    {}
+    ~FairMQMerger() {}
 
   protected:
     bool fMultipart;
     std::string fInChannelName;
     std::string fOutChannelName;
 
-    virtual void RegisterChannelEndpoints() override;
+    void InitTask() override
-    virtual void Run() override;
+    {
-    virtual 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;
+                        }
+                    }
+                }
+            }
+        }
+    }
 };
 
 #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

@@ -12,12 +12,18 @@
 #include "FairMQDevice.h"
 
 #include <string>
+#include <vector>
 
 class FairMQMultiplier : public FairMQDevice
 {
   public:
-    FairMQMultiplier();
+    FairMQMultiplier()
-    virtual ~FairMQMultiplier();
+        : fMultipart(true)
+        , fNumOutputs(0)
+        , fInChannelName()
+        , fOutChannelNames()
+    {}
+    ~FairMQMultiplier() {}
 
   protected:
     bool fMultipart;
@@ -25,10 +31,80 @@ class FairMQMultiplier : public FairMQDevice
     std::string fInChannelName;
     std::vector<std::string> fOutChannelNames;
 
-    virtual void InitTask();
+    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();
 
-    bool HandleSingleData(std::unique_ptr<FairMQMessage>&, int);
+        if (fMultipart) {
-    bool HandleMultipartData(FairMQParts&, int);
+            OnData(fInChannelName, &FairMQMultiplier::HandleMultipartData);
+        } else {
+            OnData(fInChannelName, &FairMQMultiplier::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;
+    }
 };
 
 #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

@@ -22,16 +22,55 @@
 class FairMQProxy : public FairMQDevice
 {
   public:
-    FairMQProxy();
+    FairMQProxy()
-    virtual ~FairMQProxy();
+        : fMultipart(true)
+        , fInChannelName()
+        , fOutChannelName()
+    {}
+    ~FairMQProxy() {}
 
   protected:
     bool fMultipart;
     std::string fInChannelName;
     std::string fOutChannelName;
 
-    virtual void Run();
+    void InitTask() override
-    virtual void InitTask();
+    {
+        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;
+                }
+            }
+        }
+    }
 };
 
 #endif /* FAIRMQPROXY_H_ */

fairmq/devices/FairMQSink.h

@@ -15,14 +15,14 @@
 #ifndef FAIRMQSINK_H_
 #define FAIRMQSINK_H_
 
-#include <string>
-#include <chrono>
-
 #include "../FairMQDevice.h"
 #include "../FairMQLogger.h"
 
+#include <chrono>
+#include <string>
+
 // template<typename OutputPolicy>
-class FairMQSink : public FairMQDevice//, public OutputPolicy
+class FairMQSink : public FairMQDevice   //, public OutputPolicy
 {
   public:
     FairMQSink()
@@ -32,8 +32,7 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
         , fInChannelName()
     {}
 
-    virtual ~FairMQSink()
+    ~FairMQSink() {}
-    {}
 
   protected:
     bool fMultipart;
@@ -41,14 +40,14 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
     uint64_t fNumIterations;
     std::string fInChannelName;
 
-    virtual void InitTask()
+    void InitTask() override
     {
         fMultipart = fConfig->GetProperty<bool>("multipart");
         fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
         fInChannelName = fConfig->GetProperty<std::string>("in-channel");
     }
 
-    virtual void Run()
+    void Run() override
     {
         // store the channel reference to avoid traversing the map on every loop iteration
         FairMQChannel& dataInChannel = fChannels.at(fInChannelName).at(0);
@@ -56,35 +55,25 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
         LOG(info) << "Starting the benchmark and expecting to receive " << fMaxIterations << " messages.";
         auto tStart = std::chrono::high_resolution_clock::now();
 
-        while (!NewStatePending())
+        while (!NewStatePending()) {
-        {
+            if (fMultipart) {
-            if (fMultipart)
-            {
                 FairMQParts parts;
 
-                if (dataInChannel.Receive(parts) >= 0)
+                if (dataInChannel.Receive(parts) >= 0) {
-                {
+                    if (fMaxIterations > 0) {
-                    if (fMaxIterations > 0)
+                        if (fNumIterations >= fMaxIterations) {
-                    {
-                        if (fNumIterations >= fMaxIterations)
-                        {
                             LOG(info) << "Configured maximum number of iterations reached.";
                             break;
                         }
                     }
                     fNumIterations++;
                 }
-            }
+            } else {
-            else
-            {
                 FairMQMessagePtr msg(dataInChannel.NewMessage());
 
-                if (dataInChannel.Receive(msg) >= 0)
+                if (dataInChannel.Receive(msg) >= 0) {
-                {
+                    if (fMaxIterations > 0) {
-                    if (fMaxIterations > 0)
+                        if (fNumIterations >= fMaxIterations) {
-                    {
-                        if (fNumIterations >= fMaxIterations)
-                        {
                             LOG(info) << "Configured maximum number of iterations reached.";
                             break;
                         }
@@ -96,7 +85,8 @@ class FairMQSink : public FairMQDevice//, public OutputPolicy
 
         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.";
+        LOG(info) << "Leaving RUNNING state. Received " << fNumIterations << " messages in "
+                  << std::chrono::duration<double, std::milli>(tEnd - tStart).count() << "ms.";
     }
 };
 

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

@@ -22,8 +22,14 @@
 class FairMQSplitter : public FairMQDevice
 {
   public:
-    FairMQSplitter();
+    FairMQSplitter()
-    virtual ~FairMQSplitter();
+        : fMultipart(true)
+        , fNumOutputs(0)
+        , fDirection(0)
+        , fInChannelName()
+        , fOutChannelName()
+    {}
+    ~FairMQSplitter() {}
 
   protected:
     bool fMultipart;
@@ -32,10 +38,32 @@ class FairMQSplitter : public FairMQDevice
     std::string fInChannelName;
     std::string fOutChannelName;
 
-    virtual void InitTask();
+    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;
 
-    bool HandleSingleData(std::unique_ptr<FairMQMessage>&, int);
+        if (fMultipart) {
-    bool HandleMultipartData(FairMQParts&, int);
+            OnData(fInChannelName, &FairMQSplitter::HandleData<FairMQParts>);
+        } else {
+            OnData(fInChannelName, &FairMQSplitter::HandleData<FairMQMessagePtr>);
+        }
+    }
+
+    template<typename T>
+    bool HandleData(T& payload, int)
+    {
+        Send(payload, fOutChannelName, fDirection);
+
+        if (++fDirection >= fNumOutputs) {
+            fDirection = 0;
+        }
+
+        return true;
+    }
 };
 
 #endif /* FAIRMQSPLITTER_H_ */

fairmq/nanomsg/FairMQMessageNN.cxx

@@ -1,227 +0,0 @@
-/********************************************************************************
- *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-/**
- * FairMQMessageNN.cxx
- *
- * @since 2013-12-05
- * @author A. Rybalchenko
- */
-
-#include <cstring>
-#include <stdlib.h>
-
-#include <nanomsg/nn.h>
-
-#include "FairMQMessageNN.h"
-#include "FairMQLogger.h"
-
-using namespace std;
-
-fair::mq::Transport FairMQMessageNN::fTransportType = fair::mq::Transport::NN;
-
-FairMQMessageNN::FairMQMessageNN(FairMQTransportFactory* factory)
-    : FairMQMessage{factory}
-    , fMessage(nullptr)
-    , fSize(0)
-    , fHint(0)
-    , fReceiving(false)
-    , fRegionPtr(nullptr)
-{
-    fMessage = nn_allocmsg(0, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-}
-
-FairMQMessageNN::FairMQMessageNN(const size_t size, FairMQTransportFactory* factory)
-    : FairMQMessage{factory}
-    , fMessage(nullptr)
-    , fSize(0)
-    , fHint(0)
-    , fReceiving(false)
-    , fRegionPtr(nullptr)
-{
-    fMessage = nn_allocmsg(size, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-    fSize = size;
-}
-
-
-/* nanomsg does not offer support for creating a message out of an existing buffer,
- * therefore the following method is using memcpy. For more efficient handling,
- * create FairMQMessage object only with size parameter and fill it with data.
- * possible TODO: make this zero copy (will should then be as efficient as ZeroMQ).
-*/
-FairMQMessageNN::FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint, FairMQTransportFactory* factory)
-    : FairMQMessage{factory}
-    , fMessage(nullptr)
-    , fSize(0)
-    , fHint(0)
-    , fReceiving(false)
-    , fRegionPtr(nullptr)
-{
-    fMessage = nn_allocmsg(size, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-    else
-    {
-        memcpy(fMessage, data, size);
-        fSize = size;
-        if (ffn)
-        {
-            ffn(data, hint);
-        }
-        else
-        {
-            free(data);
-        }
-    }
-}
-
-FairMQMessageNN::FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint, FairMQTransportFactory* factory)
-    : FairMQMessage{factory}
-    , fMessage(data)
-    , fSize(size)
-    , fHint(reinterpret_cast<size_t>(hint))
-    , fReceiving(false)
-    , fRegionPtr(region.get())
-{
-    // currently nanomsg will copy the buffer (data) inside nn_sendmsg()
-}
-
-void FairMQMessageNN::Rebuild()
-{
-    CloseMessage();
-    fReceiving = false;
-}
-
-void FairMQMessageNN::Rebuild(const size_t size)
-{
-    CloseMessage();
-    fMessage = nn_allocmsg(size, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-    fSize = size;
-    fReceiving = false;
-}
-
-void FairMQMessageNN::Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
-{
-    CloseMessage();
-    fMessage = nn_allocmsg(size, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-    else
-    {
-        memcpy(fMessage, data, size);
-        fSize = size;
-        fReceiving = false;
-
-        if (ffn)
-        {
-            ffn(data, hint);
-        }
-    }
-}
-
-void* FairMQMessageNN::GetMessage() const
-{
-    return fMessage;
-}
-
-void* FairMQMessageNN::GetData() const
-{
-    return fMessage;
-}
-
-size_t FairMQMessageNN::GetSize() const
-{
-    return fSize;
-}
-
-bool FairMQMessageNN::SetUsedSize(const size_t size)
-{
-    if (size <= fSize)
-    {
-        // with size smaller than original nanomsg will simply "chop" the data, avoiding reallocation
-        fMessage = nn_reallocmsg(fMessage, size);
-        fSize = size;
-        return true;
-    }
-    else
-    {
-        LOG(error) << "cannot set used size higher than original.";
-        return false;
-    }
-}
-
-void FairMQMessageNN::SetMessage(void* data, const size_t size)
-{
-    fMessage = data;
-    fSize = size;
-}
-
-fair::mq::Transport FairMQMessageNN::GetType() const
-{
-    return fTransportType;
-}
-
-void FairMQMessageNN::Copy(const FairMQMessage& msg)
-{
-    if (fMessage)
-    {
-        if (nn_freemsg(fMessage) < 0)
-        {
-            LOG(error) << "failed freeing message, reason: " << nn_strerror(errno);
-        }
-    }
-
-    size_t size = msg.GetSize();
-
-    fMessage = nn_allocmsg(size, 0);
-    if (!fMessage)
-    {
-        LOG(error) << "failed allocating message, reason: " << nn_strerror(errno);
-    }
-    else
-    {
-        memcpy(fMessage, static_cast<const FairMQMessageNN&>(msg).GetMessage(), size);
-        fSize = size;
-    }
-}
-
-void FairMQMessageNN::CloseMessage()
-{
-    if (nn_freemsg(fMessage) < 0)
-    {
-        LOG(error) << "failed freeing message, reason: " << nn_strerror(errno);
-    }
-    else
-    {
-        fMessage = nullptr;
-        fSize = 0;
-    }
-}
-
-FairMQMessageNN::~FairMQMessageNN()
-{
-    if (fReceiving)
-    {
-        CloseMessage();
-    }
-}

fairmq/nanomsg/FairMQMessageNN.h

@@ -1,68 +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"                       *
- ********************************************************************************/
-/**
- * FairMQMessageNN.h
- *
- * @since 2013-12-05
- * @author A. Rybalchenko
- */
-
-#ifndef FAIRMQMESSAGENN_H_
-#define FAIRMQMESSAGENN_H_
-
-#include <cstddef>
-#include <string>
-#include <memory>
-
-#include "FairMQMessage.h"
-#include "FairMQUnmanagedRegion.h"
-
-class FairMQSocketNN;
-
-class FairMQMessageNN final : public FairMQMessage
-{
-    friend class FairMQSocketNN;
-
-  public:
-    FairMQMessageNN(FairMQTransportFactory* factory = nullptr);
-    FairMQMessageNN(const size_t size, FairMQTransportFactory* factory = nullptr);
-    FairMQMessageNN(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr, FairMQTransportFactory* factory = nullptr);
-    FairMQMessageNN(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, FairMQTransportFactory* factory = nullptr);
-
-    FairMQMessageNN(const FairMQMessageNN&) = delete;
-    FairMQMessageNN operator=(const FairMQMessageNN&) = delete;
-
-    void Rebuild() override;
-    void Rebuild(const size_t size) override;
-    void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override;
-
-    void* GetData() const override;
-    size_t GetSize() const override;
-
-    bool SetUsedSize(const size_t size) override;
-
-    fair::mq::Transport GetType() const override;
-
-    void Copy(const FairMQMessage& msg) override;
-
-    ~FairMQMessageNN() override;
-
-  private:
-    void* fMessage;
-    size_t fSize;
-    size_t fHint;
-    bool fReceiving;
-    FairMQUnmanagedRegion* fRegionPtr;
-    static fair::mq::Transport fTransportType;
-
-    void* GetMessage() const;
-    void CloseMessage();
-    void SetMessage(void* data, const size_t size);
-};
-
-#endif /* FAIRMQMESSAGENN_H_ */

fairmq/nanomsg/FairMQPollerNN.cxx

@@ -1,207 +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"                       *
- ********************************************************************************/
-/**
- * FairMQPollerNN.cxx
- *
- * @since 2014-01-23
- * @author A. Rybalchenko
- */
-
-#include <nanomsg/nn.h>
-#include <nanomsg/pipeline.h>
-#include <nanomsg/pubsub.h>
-#include <nanomsg/reqrep.h>
-#include <nanomsg/pair.h>
-
-#include "FairMQPollerNN.h"
-#include "FairMQSocketNN.h"
-#include "FairMQLogger.h"
-
-using namespace std;
-
-FairMQPollerNN::FairMQPollerNN(const vector<FairMQChannel>& channels)
-    : fItems()
-    , fNumItems(0)
-    , fOffsetMap()
-{
-    fNumItems = channels.size();
-    fItems = new nn_pollfd[fNumItems];
-
-    for (int i = 0; i < fNumItems; ++i)
-    {
-        fItems[i].fd = static_cast<const FairMQSocketNN*>(&(channels.at(i).GetSocket()))->GetSocket();
-
-        int type = 0;
-        size_t sz = sizeof(type);
-        nn_getsockopt(static_cast<const FairMQSocketNN*>(&(channels.at(i).GetSocket()))->GetSocket(), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
-
-        SetItemEvents(fItems[i], type);
-    }
-}
-
-FairMQPollerNN::FairMQPollerNN(const vector<FairMQChannel*>& channels)
-    : fItems()
-    , fNumItems(0)
-    , fOffsetMap()
-{
-    fNumItems = channels.size();
-    fItems = new nn_pollfd[fNumItems];
-
-    for (int i = 0; i < fNumItems; ++i)
-    {
-        fItems[i].fd = static_cast<const FairMQSocketNN*>(&(channels.at(i)->GetSocket()))->GetSocket();
-
-        int type = 0;
-        size_t sz = sizeof(type);
-        nn_getsockopt(static_cast<const FairMQSocketNN*>(&(channels.at(i)->GetSocket()))->GetSocket(), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
-
-        SetItemEvents(fItems[i], type);
-    }
-}
-
-FairMQPollerNN::FairMQPollerNN(const unordered_map<string, vector<FairMQChannel>>& channelsMap, const vector<string>& channelList)
-    : fItems()
-    , fNumItems(0)
-    , fOffsetMap()
-{
-    try
-    {
-        int offset = 0;
-        // calculate offsets and the total size of the poll item set
-        for (string channel : channelList)
-        {
-            fOffsetMap[channel] = offset;
-            offset += channelsMap.at(channel).size();
-            fNumItems += channelsMap.at(channel).size();
-        }
-
-        fItems = new nn_pollfd[fNumItems];
-
-        int index = 0;
-        for (string channel : channelList)
-        {
-            for (unsigned int i = 0; i < channelsMap.at(channel).size(); ++i)
-            {
-                index = fOffsetMap[channel] + i;
-                fItems[index].fd = static_cast<const FairMQSocketNN*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket();
-
-                int type = 0;
-                size_t sz = sizeof(type);
-                nn_getsockopt(static_cast<const FairMQSocketNN*>(&(channelsMap.at(channel).at(i).GetSocket()))->GetSocket(), NN_SOL_SOCKET, NN_PROTOCOL, &type, &sz);
-
-                SetItemEvents(fItems[index], type);
-            }
-        }
-    }
-    catch (const std::out_of_range& oor)
-    {
-        LOG(error) << "at least one of the provided channel keys for poller initialization is invalid";
-        LOG(error) << "out of range error: " << oor.what() << '\n';
-        exit(EXIT_FAILURE);
-    }
-}
-
-void FairMQPollerNN::SetItemEvents(nn_pollfd& item, const int type)
-{
-    if (type == NN_REQ || type == NN_REP || type == NN_PAIR)
-    {
-        item.events = NN_POLLIN|NN_POLLOUT;
-    }
-    else if (type == NN_PUSH || type == NN_PUB)
-    {
-        item.events = NN_POLLOUT;
-    }
-    else if (type == NN_PULL || type == NN_SUB)
-    {
-        item.events = NN_POLLIN;
-    }
-    else
-    {
-        LOG(error) << "invalid poller configuration, exiting.";
-        exit(EXIT_FAILURE);
-    }
-}
-
-void FairMQPollerNN::Poll(const int timeout)
-{
-    if (nn_poll(fItems, fNumItems, timeout) < 0)
-    {
-        if (errno == ETERM)
-        {
-            LOG(debug) << "polling exited, reason: " << nn_strerror(errno);
-        }
-        else
-        {
-            LOG(error) << "polling failed, reason: " << nn_strerror(errno);
-            throw std::runtime_error("polling failed");
-        }
-    }
-}
-
-bool FairMQPollerNN::CheckInput(const int index)
-{
-    if (fItems[index].revents & (NN_POLLIN | NN_POLLOUT))
-    {
-        return true;
-    }
-
-    return false;
-}
-
-bool FairMQPollerNN::CheckOutput(const int index)
-{
-    if (fItems[index].revents & NN_POLLOUT)
-    {
-        return true;
-    }
-
-    return false;
-}
-
-bool FairMQPollerNN::CheckInput(const string& channelKey, const int index)
-{
-    try
-    {
-        if (fItems[fOffsetMap.at(channelKey) + index].revents & (NN_POLLIN | NN_POLLOUT))
-        {
-            return true;
-        }
-
-        return false;
-    }
-    catch (const std::out_of_range& oor)
-    {
-        LOG(error) << "invalid channel key: \"" << channelKey << "\"";
-        LOG(error) << "out of range error: " << oor.what() << '\n';
-        exit(EXIT_FAILURE);
-    }
-}
-
-bool FairMQPollerNN::CheckOutput(const string& channelKey, const int index)
-{
-    try
-    {
-        if (fItems[fOffsetMap.at(channelKey) + index].revents & NN_POLLOUT)
-        {
-            return true;
-        }
-
-        return false;
-    }
-    catch (const std::out_of_range& oor)
-    {
-        LOG(error) << "invalid channel key: \"" << channelKey << "\"";
-        LOG(error) << "out of range error: " << oor.what() << '\n';
-        exit(EXIT_FAILURE);
-    }
-}
-
-FairMQPollerNN::~FairMQPollerNN()
-{
-    delete[] fItems;
-}

fairmq/nanomsg/FairMQPollerNN.h

@@ -1,58 +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"                       *
- ********************************************************************************/
-/**
- * FairMQPollerNN.h
- *
- * @since 2014-01-23
- * @author A. Rybalchenko
- */
-
-#ifndef FAIRMQPOLLERNN_H_
-#define FAIRMQPOLLERNN_H_
-
-#include <vector>
-#include <unordered_map>
-
-#include "FairMQPoller.h"
-#include "FairMQChannel.h"
-#include "FairMQTransportFactoryNN.h"
-
-class FairMQChannel;
-struct nn_pollfd;
-
-class FairMQPollerNN final : public FairMQPoller
-{
-    friend class FairMQChannel;
-    friend class FairMQTransportFactoryNN;
-
-  public:
-    FairMQPollerNN(const std::vector<FairMQChannel>& channels);
-    FairMQPollerNN(const std::vector<FairMQChannel*>& channels);
-    FairMQPollerNN(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList);
-
-    FairMQPollerNN(const FairMQPollerNN&) = delete;
-    FairMQPollerNN operator=(const FairMQPollerNN&) = delete;
-
-    void SetItemEvents(nn_pollfd& item, const int type);
-
-    void Poll(const int timeout) override;
-    bool CheckInput(const int index) override;
-    bool CheckOutput(const int index) override;
-    bool CheckInput(const std::string& channelKey, const int index) override;
-    bool CheckOutput(const std::string& channelKey, const int index) override;
-
-    ~FairMQPollerNN() override;
-
-  private:
-    nn_pollfd* fItems;
-    int fNumItems;
-
-    std::unordered_map<std::string, int> fOffsetMap;
-};
-
-#endif /* FAIRMQPOLLERNN_H_ */

fairmq/nanomsg/FairMQSocketNN.cxx

@@ -1,628 +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"                       *
- ********************************************************************************/
-/**
- * FairMQSocketNN.cxx
- *
- * @since 2012-12-05
- * @author A. Rybalchenko
- */
-
-#include "FairMQSocketNN.h"
-#include "FairMQMessageNN.h"
-#include "FairMQLogger.h"
-#include "FairMQUnmanagedRegionNN.h"
-#include <fairmq/Tools.h>
-
-#include <nanomsg/nn.h>
-#include <nanomsg/pipeline.h>
-#include <nanomsg/pubsub.h>
-#include <nanomsg/reqrep.h>
-#include <nanomsg/pair.h>
-
-#include <sstream>
-#include <msgpack.hpp>
-
-using namespace std;
-using namespace fair::mq;
-
-atomic<bool> FairMQSocketNN::fInterrupted(false);
-
-FairMQSocketNN::FairMQSocketNN(const string& type, const string& name, const string& id /*= ""*/, FairMQTransportFactory* fac /*=nullptr*/)
-    : FairMQSocket{fac}
-    , fSocket(-1)
-    , fId(id + "." + name + "." + type)
-    , fBytesTx(0)
-    , fBytesRx(0)
-    , fMessagesTx(0)
-    , fMessagesRx(0)
-    , fSndTimeout(100)
-    , fRcvTimeout(100)
-    , fLinger(500)
-{
-    if (type == "router" || type == "dealer")
-    {
-        // Additional info about using the sockets ROUTER and DEALER with nanomsg can be found in:
-        // http://250bpm.com/blog:14
-        // http://www.freelists.org/post/nanomsg/a-stupid-load-balancing-question,1
-        fSocket = nn_socket(AF_SP_RAW, GetConstant(type));
-        if (fSocket == -1)
-        {
-            LOG(error) << "failed creating socket " << fId << ", reason: " << nn_strerror(errno);
-            exit(EXIT_FAILURE);
-        }
-    }
-    else
-    {
-        fSocket = nn_socket(AF_SP, GetConstant(type));
-        if (fSocket == -1)
-        {
-            LOG(error) << "failed creating socket " << fId << ", reason: " << nn_strerror(errno);
-            exit(EXIT_FAILURE);
-        }
-        if (type == "sub")
-        {
-            nn_setsockopt(fSocket, NN_SUB, NN_SUB_SUBSCRIBE, nullptr, 0);
-        }
-    }
-
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDTIMEO, &fSndTimeout, sizeof(fSndTimeout)) != 0)
-    {
-        LOG(error) << "Failed setting NN_SNDTIMEO socket option, reason: " << nn_strerror(errno);
-    }
-
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVTIMEO, &fRcvTimeout, sizeof(fRcvTimeout)) != 0)
-    {
-        LOG(error) << "Failed setting NN_RCVTIMEO socket option, reason: " << nn_strerror(errno);
-    }
-
-#ifdef NN_RCVMAXSIZE
-    int rcvSize = -1;
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVMAXSIZE, &rcvSize, sizeof(rcvSize)) != 0)
-    {
-        LOG(error) << "Failed setting NN_RCVMAXSIZE socket option, reason: " << nn_strerror(errno);
-    }
-#endif
-
-    LOG(debug) << "Created socket " << GetId();
-}
-
-bool FairMQSocketNN::Bind(const string& address)
-{
-    // LOG(info) << "bind socket " << fId << " on " << address;
-
-    if (nn_bind(fSocket, address.c_str()) < 0)
-    {
-        LOG(error) << "failed binding socket " << fId << ", reason: " << nn_strerror(errno);
-        return false;
-    }
-
-    return true;
-}
-
-bool FairMQSocketNN::Connect(const string& address)
-{
-    // LOG(info) << "connect socket " << fId << " to " << address;
-
-    if (nn_connect(fSocket, address.c_str()) < 0)
-    {
-        LOG(error) << "failed connecting socket " << fId << ", reason: " << nn_strerror(errno);
-        return false;
-    }
-
-    return true;
-}
-
-int FairMQSocketNN::Send(FairMQMessagePtr& msg, const int timeout)
-{
-    int flags = 0;
-    if (timeout == 0)
-    {
-        flags = NN_DONTWAIT;
-    }
-    int nbytes = -1;
-    int elapsed = 0;
-
-    FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get());
-    void* bufPtr = msgPtr->GetMessage();
-
-    while (true)
-    {
-        if (msgPtr->fRegionPtr == nullptr)
-        {
-            nbytes = nn_send(fSocket, &bufPtr, NN_MSG, flags);
-        }
-        else
-        {
-            nbytes = nn_send(fSocket, bufPtr, msg->GetSize(), flags);
-            // nn_send copies the data, safe to call region callback here
-            static_cast<FairMQUnmanagedRegionNN*>(msgPtr->fRegionPtr)->fCallback(bufPtr, msg->GetSize(), reinterpret_cast<void*>(msgPtr->fHint));
-        }
-
-        if (nbytes >= 0)
-        {
-            fBytesTx += nbytes;
-            ++fMessagesTx;
-            static_cast<FairMQMessageNN*>(msg.get())->fReceiving = false;
-
-            return nbytes;
-        }
-        else if (nn_errno() == ETIMEDOUT)
-        {
-            if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
-            {
-                if (timeout > 0)
-                {
-                    elapsed += fSndTimeout;
-                    if (elapsed >= timeout)
-                    {
-                        return -2;
-                    }
-                }
-                continue;
-            }
-            else
-            {
-                return -2;
-            }
-        }
-        else if (nn_errno() == EAGAIN)
-        {
-            return -2;
-        }
-        else if (nn_errno() == ETERM)
-        {
-            LOG(info) << "terminating socket " << fId;
-            return -1;
-        }
-        else
-        {
-            LOG(error) << "Failed sending on socket " << fId << ", reason: " << nn_strerror(errno);
-            return nbytes;
-        }
-    }
-}
-
-int FairMQSocketNN::Receive(FairMQMessagePtr& msg, const int timeout)
-{
-    int flags = 0;
-    if (timeout == 0)
-    {
-        flags = NN_DONTWAIT;
-    }
-    int elapsed = 0;
-
-    FairMQMessageNN* msgPtr = static_cast<FairMQMessageNN*>(msg.get());
-
-    while (true)
-    {
-        void* ptr = nullptr;
-        int nbytes = nn_recv(fSocket, &ptr, NN_MSG, flags);
-        if (nbytes >= 0)
-        {
-            fBytesRx += nbytes;
-            ++fMessagesRx;
-            msgPtr->SetMessage(ptr, nbytes);
-            msgPtr->fReceiving = true;
-            return nbytes;
-        }
-        else if (nn_errno() == ETIMEDOUT)
-        {
-            if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
-            {
-                if (timeout > 0)
-                {
-                    elapsed += fRcvTimeout;
-                    if (elapsed >= timeout)
-                    {
-                        return -2;
-                    }
-                }
-                continue;
-            }
-            else
-            {
-                return -2;
-            }
-        }
-        else if (nn_errno() == EAGAIN)
-        {
-            return -2;
-        }
-        else if (nn_errno() == ETERM)
-        {
-            LOG(info) << "terminating socket " << fId;
-            return -1;
-        }
-        else
-        {
-            LOG(error) << "Failed receiving on socket " << fId << ", reason: " << nn_strerror(errno);
-            return nbytes;
-        }
-    }
-}
-
-int64_t FairMQSocketNN::Send(vector<FairMQMessagePtr>& msgVec, const int timeout)
-{
-    int flags = 0;
-    if (timeout == 0)
-    {
-        flags = NN_DONTWAIT;
-    }
-    const unsigned int vecSize = msgVec.size();
-    int elapsed = 0;
-
-    // create msgpack simple buffer
-    msgpack::sbuffer sbuf;
-    // create msgpack packer
-    msgpack::packer<msgpack::sbuffer> packer(&sbuf);
-
-    // pack all parts into a single msgpack simple buffer
-    for (unsigned int i = 0; i < vecSize; ++i)
-    {
-        FairMQMessageNN* partPtr = static_cast<FairMQMessageNN*>(msgVec[i].get());
-
-        partPtr->fReceiving = false;
-        packer.pack_bin(msgVec[i]->GetSize());
-        packer.pack_bin_body(static_cast<char*>(msgVec[i]->GetData()), msgVec[i]->GetSize());
-        // call region callback
-        if (partPtr->fRegionPtr)
-        {
-            static_cast<FairMQUnmanagedRegionNN*>(partPtr->fRegionPtr)->fCallback(partPtr->GetMessage(), partPtr->GetSize(), reinterpret_cast<void*>(partPtr->fHint));
-        }
-    }
-
-    while (true)
-    {
-        int64_t nbytes = nn_send(fSocket, sbuf.data(), sbuf.size(), flags);
-        if (nbytes >= 0)
-        {
-            fBytesTx += nbytes;
-            ++fMessagesTx;
-            return nbytes;
-        }
-        else if (nn_errno() == ETIMEDOUT)
-        {
-            if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
-            {
-                if (timeout > 0)
-                {
-                    elapsed += fSndTimeout;
-                    if (elapsed >= timeout)
-                    {
-                        return -2;
-                    }
-                }
-                continue;
-            }
-            else
-            {
-                return -2;
-            }
-        }
-        else if (nn_errno() == EAGAIN)
-        {
-            return -2;
-        }
-        else if (nn_errno() == ETERM)
-        {
-            LOG(info) << "terminating socket " << fId;
-            return -1;
-        }
-        else
-        {
-            LOG(error) << "Failed sending on socket " << fId << ", reason: " << nn_strerror(errno);
-            return nbytes;
-        }
-    }
-}
-
-int64_t FairMQSocketNN::Receive(vector<FairMQMessagePtr>& msgVec, const int timeout)
-{
-    int flags = 0;
-    if (timeout == 0)
-    {
-        flags = NN_DONTWAIT;
-    }
-    // Warn if the vector is filled before Receive() and empty it.
-    // if (msgVec.size() > 0)
-    // {
-    //     LOG(warn) << "Message vector contains elements before Receive(), they will be deleted!";
-    //     msgVec.clear();
-    // }
-
-    int elapsed = 0;
-
-    while (true)
-    {
-        // pointer to point to received message buffer
-        char* ptr = nullptr;
-        // receive the message into a buffer allocated by nanomsg and let ptr point to it
-        int nbytes = nn_recv(fSocket, &ptr, NN_MSG, flags);
-        if (nbytes >= 0) // if no errors or non-blocking timeouts
-        {
-            // store statistics on how many bytes received
-            fBytesRx += nbytes;
-            // store statistics on how many messages received (count messages instead of parts)
-            ++fMessagesRx;
-
-            // offset to be used by msgpack to handle separate chunks
-            size_t offset = 0;
-            while (offset != static_cast<size_t>(nbytes)) // continue until all parts have been read
-            {
-                // vector of chars to hold blob (unlike char*/void* this type can be converted to by msgpack)
-                vector<char> buf;
-
-                // unpack and convert chunk
-                msgpack::unpacked result;
-                unpack(result, ptr, nbytes, offset);
-                msgpack::object object(result.get());
-                object.convert(buf);
-                // get the single message size
-                size_t size = buf.size() * sizeof(char);
-                FairMQMessagePtr part(new FairMQMessageNN(size, GetTransport()));
-                static_cast<FairMQMessageNN*>(part.get())->fReceiving = true;
-                memcpy(part->GetData(), buf.data(), size);
-                msgVec.push_back(move(part));
-            }
-
-            nn_freemsg(ptr);
-            return nbytes;
-        }
-        else if (nn_errno() == ETIMEDOUT)
-        {
-            if (!fInterrupted && ((flags & NN_DONTWAIT) == 0))
-            {
-                if (timeout > 0)
-                {
-                    elapsed += fRcvTimeout;
-                    if (elapsed >= timeout)
-                    {
-                        return -2;
-                    }
-                }
-                continue;
-            }
-            else
-            {
-                return -2;
-            }
-        }
-        else if (nn_errno() == EAGAIN)
-        {
-            return -2;
-        }
-        else if (nn_errno() == ETERM)
-        {
-            LOG(info) << "terminating socket " << fId;
-            return -1;
-        }
-        else
-        {
-            LOG(error) << "Failed receiving on socket " << fId << ", reason: " << nn_strerror(errno);
-            return nbytes;
-        }
-    }
-}
-
-void FairMQSocketNN::Close()
-{
-    nn_close(fSocket);
-}
-
-void FairMQSocketNN::Interrupt()
-{
-    fInterrupted = true;
-}
-
-void FairMQSocketNN::Resume()
-{
-    fInterrupted = false;
-}
-
-int FairMQSocketNN::GetSocket() const
-{
-    return fSocket;
-}
-
-void FairMQSocketNN::SetOption(const string& option, const void* value, size_t valueSize)
-{
-    if (option == "snd-size" || option == "rcv-size")
-    {
-        int val = *(static_cast<int*>(const_cast<void*>(value)));
-        if (val <= 0)
-        {
-            LOG(warn) << "value for sndKernelSize/rcvKernelSize should be greater than 0, leaving unchanged.";
-            return;
-        }
-    }
-
-    if (option == "snd-hwm" || option == "rcv-hwm")
-    {
-        return;
-    }
-
-    if (option == "linger")
-    {
-        fLinger = *static_cast<int*>(const_cast<void*>(value));
-        return;
-    }
-
-    int rc = nn_setsockopt(fSocket, NN_SOL_SOCKET, GetConstant(option), value, valueSize);
-    if (rc < 0)
-    {
-        LOG(error) << "failed setting socket option, reason: " << nn_strerror(errno);
-    }
-}
-
-void FairMQSocketNN::GetOption(const string& option, void* value, size_t* valueSize)
-{
-    if (option == "linger")
-    {
-        *static_cast<int*>(value) = fLinger;
-        return;
-    }
-
-    if (option == "snd-hwm" || option == "rcv-hwm")
-    {
-        *static_cast<int*>(value) = -1;
-        return;
-    }
-
-
-    int rc = nn_getsockopt(fSocket, NN_SOL_SOCKET, GetConstant(option), value, valueSize);
-    if (rc < 0)
-    {
-        LOG(error) << "failed getting socket option, reason: " << nn_strerror(errno);
-    }
-}
-
-void FairMQSocketNN::SetLinger(const int value)
-{
-    fLinger = value;
-}
-
-int FairMQSocketNN::GetLinger() const
-{
-    return fLinger;
-}
-
-void FairMQSocketNN::SetSndBufSize(const int /* value */)
-{
-    // not used in nanomsg
-}
-
-int FairMQSocketNN::GetSndBufSize() const
-{
-    // not used in nanomsg
-    return -1;
-}
-
-void FairMQSocketNN::SetRcvBufSize(const int /* value */)
-{
-    // not used in nanomsg
-}
-
-int FairMQSocketNN::GetRcvBufSize() const
-{
-    // not used in nanomsg
-    return -1;
-}
-
-void FairMQSocketNN::SetSndKernelSize(const int value)
-{
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_SNDBUF, &value, sizeof(value)) < 0) {
-        throw SocketError(tools::ToString("failed setting NN_SNDBUF, reason: ", nn_strerror(errno)));
-    }
-}
-
-int FairMQSocketNN::GetSndKernelSize() const
-{
-    int value = 0;
-    size_t valueSize;
-    if (nn_getsockopt(fSocket, NN_SOL_SOCKET, NN_SNDBUF, &value, &valueSize) < 0) {
-        throw SocketError(tools::ToString("failed getting NN_SNDBUF, reason: ", nn_strerror(errno)));
-    }
-    return value;
-}
-
-void FairMQSocketNN::SetRcvKernelSize(const int value)
-{
-    if (nn_setsockopt(fSocket, NN_SOL_SOCKET, NN_RCVBUF, &value, sizeof(value)) < 0) {
-        throw SocketError(tools::ToString("failed setting NN_RCVBUF, reason: ", nn_strerror(errno)));
-    }
-}
-
-int FairMQSocketNN::GetRcvKernelSize() const
-{
-    int value = 0;
-    size_t valueSize;
-    if (nn_getsockopt(fSocket, NN_SOL_SOCKET, NN_RCVBUF, &value, &valueSize) < 0) {
-        throw SocketError(tools::ToString("failed getting NN_RCVBUF, reason: ", nn_strerror(errno)));
-    }
-    return value;
-}
-
-
-unsigned long FairMQSocketNN::GetBytesTx() const
-{
-    return fBytesTx;
-}
-
-unsigned long FairMQSocketNN::GetBytesRx() const
-{
-    return fBytesRx;
-}
-
-unsigned long FairMQSocketNN::GetMessagesTx() const
-{
-    return fMessagesTx;
-}
-
-unsigned long FairMQSocketNN::GetMessagesRx() const
-{
-    return fMessagesRx;
-}
-
-int FairMQSocketNN::GetConstant(const string& constant)
-{
-    if (constant == "")
-        return 0;
-    if (constant == "sub")
-        return NN_SUB;
-    if (constant == "pub")
-        return NN_PUB;
-    if (constant == "xsub")
-        return NN_SUB;
-    if (constant == "xpub")
-        return NN_PUB;
-    if (constant == "push")
-        return NN_PUSH;
-    if (constant == "pull")
-        return NN_PULL;
-    if (constant == "req")
-        return NN_REQ;
-    if (constant == "rep")
-        return NN_REP;
-    if (constant == "dealer")
-        return NN_REQ;
-    if (constant == "router")
-        return NN_REP;
-    if (constant == "pair")
-        return NN_PAIR;
-
-    if (constant == "snd-hwm")
-        return NN_SNDBUF;
-    if (constant == "rcv-hwm")
-        return NN_RCVBUF;
-    if (constant == "snd-size")
-        return NN_SNDBUF;
-    if (constant == "rcv-size")
-        return NN_RCVBUF;
-    if (constant == "snd-more")
-    {
-        LOG(error) << "Multipart messages functionality currently not supported by nanomsg!";
-        return -1;
-    }
-    if (constant == "rcv-more")
-    {
-        LOG(error) << "Multipart messages functionality currently not supported by nanomsg!";
-        return -1;
-    }
-
-    if (constant == "linger")
-        return NN_LINGER;
-    if (constant == "no-block")
-        return NN_DONTWAIT;
-
-    return -1;
-}
-
-FairMQSocketNN::~FairMQSocketNN()
-{
-    Close();
-}

fairmq/nanomsg/FairMQSocketNN.h

@@ -1,81 +0,0 @@
-/********************************************************************************
- * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-
-#ifndef FAIRMQSOCKETNN_H_
-#define FAIRMQSOCKETNN_H_
-
-#include <vector>
-#include <atomic>
-
-#include "FairMQSocket.h"
-#include "FairMQMessage.h"
-class FairMQTransportFactory;
-
-class FairMQSocketNN final : public FairMQSocket
-{
-  public:
-    FairMQSocketNN(const std::string& type, const std::string& name, const std::string& id = "", FairMQTransportFactory* fac = nullptr);
-    FairMQSocketNN(const FairMQSocketNN&) = delete;
-    FairMQSocketNN operator=(const FairMQSocketNN&) = delete;
-
-    std::string GetId() const override { return fId; }
-
-    bool Bind(const std::string& address) override;
-    bool Connect(const std::string& address) override;
-
-    int Send(FairMQMessagePtr& msg, const int timeout = -1) override;
-    int Receive(FairMQMessagePtr& msg, const int timeout = -1) override;
-    int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
-    int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, const int timeout = -1) override;
-
-    int GetSocket() const;
-
-    void Close() override;
-
-    static void Interrupt();
-    static void Resume();
-
-    void SetOption(const std::string& option, const void* value, size_t valueSize) override;
-    void GetOption(const std::string& option, void* value, size_t* valueSize) override;
-
-    void SetLinger(const int value) override;
-    int GetLinger() const override;
-    void SetSndBufSize(const int value) override;
-    int GetSndBufSize() const override;
-    void SetRcvBufSize(const int value) override;
-    int GetRcvBufSize() const override;
-    void SetSndKernelSize(const int value) override;
-    int GetSndKernelSize() const override;
-    void SetRcvKernelSize(const int value) override;
-    int GetRcvKernelSize() const override;
-
-    unsigned long GetBytesTx() const override;
-    unsigned long GetBytesRx() const override;
-    unsigned long GetMessagesTx() const override;
-    unsigned long GetMessagesRx() const override;
-
-    static int GetConstant(const std::string& constant);
-
-    ~FairMQSocketNN() override;
-
-  private:
-    int fSocket;
-    std::string fId;
-    std::atomic<unsigned long> fBytesTx;
-    std::atomic<unsigned long> fBytesRx;
-    std::atomic<unsigned long> fMessagesTx;
-    std::atomic<unsigned long> fMessagesRx;
-
-    static std::atomic<bool> fInterrupted;
-
-    int fSndTimeout;
-    int fRcvTimeout;
-    int fLinger;
-};
-
-#endif /* FAIRMQSOCKETNN_H_ */

fairmq/nanomsg/FairMQTransportFactoryNN.cxx

@@ -1,99 +0,0 @@
-/********************************************************************************
- * Copyright (C) 2014-2017 GSI Helmholtzzentrum fuer Schwerionenforschung Gmb   *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-
-#include "FairMQTransportFactoryNN.h"
-
-#include <nanomsg/nn.h>
-#include <algorithm>
-#include <thread>
-#include <chrono>
-
-using namespace std;
-
-fair::mq::Transport FairMQTransportFactoryNN::fTransportType = fair::mq::Transport::NN;
-
-FairMQTransportFactoryNN::FairMQTransportFactoryNN(const string& id, const fair::mq::ProgOptions* /*config*/)
-    : FairMQTransportFactory(id)
-{
-    LOG(debug) << "Transport: Using nanomsg library";
-}
-
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage()
-{
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(this));
-}
-
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(const size_t size)
-{
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(size, this));
-}
-
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
-{
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(data, size, ffn, hint, this));
-}
-
-FairMQMessagePtr FairMQTransportFactoryNN::CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
-{
-    return unique_ptr<FairMQMessage>(new FairMQMessageNN(region, data, size, hint, this));
-}
-
-FairMQSocketPtr FairMQTransportFactoryNN::CreateSocket(const string& type, const string& name)
-{
-    unique_ptr<FairMQSocket> socket(new FairMQSocketNN(type, name, GetId(), this));
-    fSockets.push_back(socket.get());
-    return socket;
-}
-
-FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const vector<FairMQChannel>& channels) const
-{
-    return unique_ptr<FairMQPoller>(new FairMQPollerNN(channels));
-}
-
-FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const std::vector<FairMQChannel*>& channels) const
-{
-    return unique_ptr<FairMQPoller>(new FairMQPollerNN(channels));
-}
-
-FairMQPollerPtr FairMQTransportFactoryNN::CreatePoller(const unordered_map<string, vector<FairMQChannel>>& channelsMap, const vector<string>& channelList) const
-{
-    return unique_ptr<FairMQPoller>(new FairMQPollerNN(channelsMap, channelList));
-}
-
-FairMQUnmanagedRegionPtr FairMQTransportFactoryNN::CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback, const std::string& path /* = "" */, int flags /* = 0 */) const
-{
-    return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionNN(size, callback, path, flags));
-}
-
-FairMQUnmanagedRegionPtr FairMQTransportFactoryNN::CreateUnmanagedRegion(const size_t size, const int64_t userFlags, FairMQRegionCallback callback, const std::string& path /* = "" */, int flags /* = 0 */) const
-{
-    return unique_ptr<FairMQUnmanagedRegion>(new FairMQUnmanagedRegionNN(size, userFlags, callback, path, flags));
-}
-
-fair::mq::Transport FairMQTransportFactoryNN::GetType() const
-{
-    return fTransportType;
-}
-
-void FairMQTransportFactoryNN::Reset()
-{
-    auto it = max_element(fSockets.begin(), fSockets.end(), [](FairMQSocket* s1, FairMQSocket* s2) {
-        return static_cast<FairMQSocketNN*>(s1)->GetLinger() < static_cast<FairMQSocketNN*>(s2)->GetLinger();
-    });
-    if (it != fSockets.end()) {
-        this_thread::sleep_for(chrono::milliseconds(static_cast<FairMQSocketNN*>(*it)->GetLinger()));
-    }
-    fSockets.clear();
-}
-
-FairMQTransportFactoryNN::~FairMQTransportFactoryNN()
-{
-    LOG(debug) << "Destroying Shared Memory transport...";
-    // nn_term();
-    // see https://www.freelists.org/post/nanomsg/Getting-rid-of-nn-init-and-nn-term,8
-}

fairmq/nanomsg/FairMQTransportFactoryNN.h

@@ -1,57 +0,0 @@
-/********************************************************************************
- * Copyright (C) 2014-2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
- *                                                                              *
- *              This software is distributed under the terms of the             *
- *              GNU Lesser General Public Licence (LGPL) version 3,             *
- *                  copied verbatim in the file "LICENSE"                       *
- ********************************************************************************/
-
-#ifndef FAIRMQTRANSPORTFACTORYNN_H_
-#define FAIRMQTRANSPORTFACTORYNN_H_
-
-#include "FairMQTransportFactory.h"
-#include "FairMQMessageNN.h"
-#include "FairMQSocketNN.h"
-#include "FairMQPollerNN.h"
-#include "FairMQUnmanagedRegionNN.h"
-#include <fairmq/ProgOptions.h>
-
-#include <vector>
-#include <string>
-
-class FairMQTransportFactoryNN final : public FairMQTransportFactory
-{
-  public:
-    FairMQTransportFactoryNN(const std::string& id = "", const fair::mq::ProgOptions* config = nullptr);
-    ~FairMQTransportFactoryNN() override;
-
-    FairMQMessagePtr CreateMessage() override;
-    FairMQMessagePtr CreateMessage(const size_t size) override;
-    FairMQMessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override;
-    FairMQMessagePtr CreateMessage(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override;
-
-    FairMQSocketPtr CreateSocket(const std::string& type, const std::string& name) override;
-
-    FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override;
-    FairMQPollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override;
-    FairMQPollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override;
-
-    FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, FairMQRegionCallback callback, const std::string& path = "", int flags = 0) const override;
-    FairMQUnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, int64_t userFlags, FairMQRegionCallback callback = nullptr, const std::string& path = "", int flags = 0) const override;
-
-    void SubscribeToRegionEvents(FairMQRegionEventCallback /* callback */) override { LOG(error) << "SubscribeToRegionEvents not yet implemented for nanomsg"; }
-    void UnsubscribeFromRegionEvents() override { LOG(error) << "UnsubscribeFromRegionEvents not yet implemented for nanomsg"; }
-    std::vector<FairMQRegionInfo> GetRegionInfo() override { LOG(error) << "GetRegionInfo not yet implemented for nanomsg, returning empty vector"; return std::vector<FairMQRegionInfo>(); }
-
-    fair::mq::Transport GetType() const override;
-
-    void Interrupt() override { FairMQSocketNN::Interrupt(); }
-    void Resume() override { FairMQSocketNN::Resume(); }
-    void Reset() override;
-
-  private:
-    static fair::mq::Transport fTransportType;
-    mutable std::vector<FairMQSocket*> fSockets;
-};
-
-#endif /* FAIRMQTRANSPORTFACTORYNN_H_ */

fairmq/nanomsg/FairMQUnmanagedRegionNN.cxx

@@ -1,42 +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 "FairMQUnmanagedRegionNN.h"
-#include "FairMQLogger.h"
-
-using namespace std;
-
-FairMQUnmanagedRegionNN::FairMQUnmanagedRegionNN(const size_t size, FairMQRegionCallback callback, const std::string& /*path = "" */, int /*flags = 0 */)
-    : fBuffer(malloc(size))
-    , fSize(size)
-    , fCallback(callback)
-{
-}
-
-FairMQUnmanagedRegionNN::FairMQUnmanagedRegionNN(const size_t size, const int64_t /*userFlags*/, FairMQRegionCallback callback, const std::string& /*path = "" */, int /*flags = 0 */)
-    : fBuffer(malloc(size))
-    , fSize(size)
-    , fCallback(callback)
-{
-}
-
-void* FairMQUnmanagedRegionNN::GetData() const
-{
-    return fBuffer;
-}
-
-size_t FairMQUnmanagedRegionNN::GetSize() const
-{
-    return fSize;
-}
-
-FairMQUnmanagedRegionNN::~FairMQUnmanagedRegionNN()
-{
-    LOG(debug) << "destroying region";
-    free(fBuffer);
-}

fairmq/nanomsg/FairMQUnmanagedRegionNN.h

@@ -1,39 +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 FAIRMQUNMANAGEDREGIONNN_H_
-#define FAIRMQUNMANAGEDREGIONNN_H_
-
-#include "FairMQUnmanagedRegion.h"
-
-#include <cstddef> // size_t
-#include <string>
-
-class FairMQUnmanagedRegionNN final : public FairMQUnmanagedRegion
-{
-    friend class FairMQSocketNN;
-
-  public:
-    FairMQUnmanagedRegionNN(const size_t size, FairMQRegionCallback callback, const std::string& path = "", int flags = 0);
-    FairMQUnmanagedRegionNN(const size_t size, const int64_t userFlags, FairMQRegionCallback callback, const std::string& path = "", int flags = 0);
-
-    FairMQUnmanagedRegionNN(const FairMQUnmanagedRegionNN&) = delete;
-    FairMQUnmanagedRegionNN operator=(const FairMQUnmanagedRegionNN&) = delete;
-
-    virtual void* GetData() const override;
-    virtual size_t GetSize() const override;
-
-    virtual ~FairMQUnmanagedRegionNN();
-
-  private:
-    void* fBuffer;
-    size_t fSize;
-    FairMQRegionCallback fCallback;
-};
-
-#endif /* FAIRMQUNMANAGEDREGIONNN_H_ */

fairmq/ofi/Message.cxx

@@ -34,6 +34,16 @@ Message::Message(boost::container::pmr::memory_resource* pmr)
 {
 }
 
+Message::Message(boost::container::pmr::memory_resource* pmr, Alignment /* alignment */)
+    : fInitialSize(0)
+    , fSize(0)
+    , fData(nullptr)
+    , fFreeFunction(nullptr)
+    , fHint(nullptr)
+    , fPmr(pmr)
+{
+}
+
 Message::Message(boost::container::pmr::memory_resource* pmr, const size_t size)
     : fInitialSize(size)
     , fSize(size)
@@ -48,6 +58,20 @@ Message::Message(boost::container::pmr::memory_resource* pmr, const size_t size)
     }
 }
 
+Message::Message(boost::container::pmr::memory_resource* pmr, const size_t size, Alignment /* alignment */)
+    : fInitialSize(size)
+    , fSize(size)
+    , fData(nullptr)
+    , fFreeFunction(nullptr)
+    , fHint(nullptr)
+    , fPmr(pmr)
+{
+    if (size) {
+        fData = fPmr->allocate(size);
+        assert(fData);
+    }
+}
+
 Message::Message(boost::container::pmr::memory_resource* pmr,
                  void* data,
                  const size_t size,

fairmq/ofi/Message.h

@@ -34,7 +34,9 @@ class Message final : public fair::mq::Message
 {
   public:
     Message(boost::container::pmr::memory_resource* pmr);
+    Message(boost::container::pmr::memory_resource* pmr, Alignment alignment);
     Message(boost::container::pmr::memory_resource* pmr, const size_t size);
+    Message(boost::container::pmr::memory_resource* pmr, const size_t size, Alignment alignment);
     Message(boost::container::pmr::memory_resource* pmr,
             void* data,
             const size_t size,

fairmq/ofi/Socket.cxx

@@ -272,7 +272,7 @@ try {
     int size(0);
     for (auto& msg : msgVec) {
         size += msg->GetSize();
-    } 
+    }
 
     fSendPushSem.wait();
     {
@@ -284,7 +284,7 @@ try {
     return size;
 } catch (const std::exception& e) {
     LOG(error) << e.what();
-    return -1;
+    return static_cast<int64_t>(TransferResult::error);
 }
 
 auto Socket::SendQueueReader() -> void
@@ -431,7 +431,7 @@ try {
     return size;
 } catch (const std::exception& e) {
     LOG(error) << e.what();
-    return -1;
+    return static_cast<int>(TransferResult::error);
 }
 
 auto Socket::Receive(std::vector<MessagePtr>& msgVec, const int /*timeout*/) -> int64_t
@@ -449,14 +449,14 @@ try {
     int64_t size(0);
     for (auto& msg : msgVec) {
         size += msg->GetSize();
-    } 
+    }
     fBytesRx += size;
     ++fMessagesRx;
 
-    return size; 
+    return size;
 } catch (const std::exception& e) {
     LOG(error) << e.what();
-    return -1;
+    return static_cast<int64_t>(TransferResult::error);
 }
 
 auto Socket::RecvControlQueueReader() -> void

fairmq/ofi/Socket.h

@@ -45,6 +45,7 @@ class Socket final : public fair::mq::Socket
 
     auto GetId() const -> std::string override { return fId; }
 
+    auto Events(uint32_t *events) -> void override { *events = 0; }
     auto Bind(const std::string& address) -> bool override;
     auto Connect(const std::string& address) -> bool override;
 

fairmq/ofi/TransportFactory.cxx

@@ -41,11 +41,23 @@ auto TransportFactory::CreateMessage() -> MessagePtr
     return MessagePtr{new Message(&fMemoryResource)};
 }
 
+auto TransportFactory::CreateMessage(Alignment /* alignment */) -> MessagePtr
+{
+    // TODO Do not ignore alignment
+    return MessagePtr{new Message(&fMemoryResource)};
+}
+
 auto TransportFactory::CreateMessage(const size_t size) -> MessagePtr
 {
     return MessagePtr{new Message(&fMemoryResource, size)};
 }
 
+auto TransportFactory::CreateMessage(const size_t size, Alignment /* alignment */) -> MessagePtr
+{
+    // TODO Do not ignore alignment
+    return MessagePtr{new Message(&fMemoryResource, size)};
+}
+
 auto TransportFactory::CreateMessage(void* data,
                                      const size_t size,
                                      fairmq_free_fn* ffn,
@@ -85,12 +97,22 @@ auto TransportFactory::CreatePoller(const unordered_map<string, vector<FairMQCha
     // return PollerPtr{new Poller(channelsMap, channelList)};
 }
 
-auto TransportFactory::CreateUnmanagedRegion(const size_t /*size*/, FairMQRegionCallback /*callback*/, const std::string& /* path = "" */, int /* flags = 0 */) const -> UnmanagedRegionPtr
+auto TransportFactory::CreateUnmanagedRegion(const size_t /*size*/, FairMQRegionCallback /*callback*/, const std::string& /* path = "" */, int /* flags = 0 */) -> UnmanagedRegionPtr
 {
     throw runtime_error{"Not yet implemented UMR."};
 }
 
-auto TransportFactory::CreateUnmanagedRegion(const size_t /*size*/, const int64_t /*userFlags*/, FairMQRegionCallback /*callback*/, const std::string& /* path = "" */, int /* flags = 0 */) const -> UnmanagedRegionPtr
+auto TransportFactory::CreateUnmanagedRegion(const size_t /*size*/, FairMQRegionBulkCallback /*callback*/, const std::string& /* path = "" */, int /* flags = 0 */) -> UnmanagedRegionPtr
+{
+    throw runtime_error{"Not yet implemented UMR."};
+}
+
+auto TransportFactory::CreateUnmanagedRegion(const size_t /*size*/, const int64_t /*userFlags*/, FairMQRegionCallback /*callback*/, const std::string& /* path = "" */, int /* flags = 0 */) -> UnmanagedRegionPtr
+{
+    throw runtime_error{"Not yet implemented UMR."};
+}
+
+auto TransportFactory::CreateUnmanagedRegion(const size_t /*size*/, const int64_t /*userFlags*/, FairMQRegionBulkCallback /*callback*/, const std::string& /* path = "" */, int /* flags = 0 */) -> UnmanagedRegionPtr
 {
     throw runtime_error{"Not yet implemented UMR."};
 }

fairmq/ofi/TransportFactory.h

@@ -36,7 +36,9 @@ class TransportFactory final : public FairMQTransportFactory
     TransportFactory operator=(const TransportFactory&) = delete;
 
     auto CreateMessage() -> MessagePtr override;
+    auto CreateMessage(Alignment alignment) -> MessagePtr override;
     auto CreateMessage(const std::size_t size) -> MessagePtr override;
+    auto CreateMessage(const std::size_t size, Alignment alignment) -> MessagePtr override;
     auto CreateMessage(void* data, const std::size_t size, fairmq_free_fn* ffn, void* hint = nullptr) -> MessagePtr override;
     auto CreateMessage(UnmanagedRegionPtr& region, void* data, const std::size_t size, void* hint = nullptr) -> MessagePtr override;
 
@@ -46,10 +48,13 @@ class TransportFactory final : public FairMQTransportFactory
     auto CreatePoller(const std::vector<FairMQChannel*>& channels) const -> PollerPtr override;
     auto CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const -> PollerPtr override;
 
-    auto CreateUnmanagedRegion(const size_t size, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) const -> UnmanagedRegionPtr override;
+    auto CreateUnmanagedRegion(const size_t size, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) -> UnmanagedRegionPtr override;
-    auto CreateUnmanagedRegion(const size_t size, int64_t userFlags, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) const -> UnmanagedRegionPtr override;
+    auto CreateUnmanagedRegion(const size_t size, RegionBulkCallback callback = nullptr, const std::string& path = "", int flags = 0) -> UnmanagedRegionPtr override;
+    auto CreateUnmanagedRegion(const size_t size, int64_t userFlags, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) -> UnmanagedRegionPtr override;
+    auto CreateUnmanagedRegion(const size_t size, int64_t userFlags, RegionBulkCallback callback = nullptr, const std::string& path = "", int flags = 0) -> UnmanagedRegionPtr override;
 
     void SubscribeToRegionEvents(RegionEventCallback /* callback */) override { LOG(error) << "SubscribeToRegionEvents not yet implemented for OFI"; }
+    bool SubscribedToRegionEvents() override { LOG(error) << "Region event subscriptions not yet implemented for OFI"; return false; }
     void UnsubscribeFromRegionEvents() override { LOG(error) << "UnsubscribeFromRegionEvents not yet implemented for OFI"; }
     std::vector<FairMQRegionInfo> GetRegionInfo() override { LOG(error) << "GetRegionInfo not yet implemented for OFI, returning empty vector"; return std::vector<FairMQRegionInfo>(); }
 

fairmq/plugins/Control.cxx

@@ -8,14 +8,16 @@
 
 #include "Control.h"
 
-#include <termios.h> // for the interactive mode
+#include <atomic>
-#include <poll.h> // for the interactive mode
+#include <chrono>
 #include <csignal> // catching system signals
 #include <cstdlib>
 #include <functional>
-#include <atomic>
+#include <iostream>
 #include <thread>
-#include <chrono>
+
+#include <poll.h> // for the interactive mode
+#include <termios.h> // for the interactive mode
 
 using namespace std;
 
@@ -24,7 +26,7 @@ namespace
     std::atomic<sig_atomic_t> gLastSignal(0);
     std::atomic<int> gSignalCount(0);
 
-    extern "C" auto signal_handler(int signal) -> void
+    extern "C" auto sigint_handler(int signal) -> void
     {
         ++gSignalCount;
         gLastSignal = signal;
@@ -33,6 +35,12 @@ namespace
             std::abort();
         }
     }
+
+    extern "C" auto sigterm_handler(int signal) -> void
+    {
+        ++gSignalCount;
+        gLastSignal = signal;
+    }
 }
 
 namespace fair
@@ -85,8 +93,8 @@ Control::Control(const string& name, const Plugin::Version version, const string
     if (GetProperty<int>("catch-signals") > 0) {
         LOG(debug) << "Plugin '" << name << "' is setting up signal handling for SIGINT and SIGTERM";
         fSignalHandlerThread = thread(&Control::SignalHandler, this);
-        signal(SIGINT, signal_handler);
+        signal(SIGINT, sigint_handler);
-        signal(SIGTERM, signal_handler);
+        signal(SIGTERM, sigterm_handler);
     } else {
         LOG(warn) << "Signal handling (e.g. Ctrl-C) has been deactivated.";
     }

fairmq/plugins/DDS/CMakeLists.txt

@@ -17,13 +17,7 @@ set_target_properties(${plugin} PROPERTIES
   LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/fairmq
 )
 
-set(exe fairmq-dds-command-ui)
+install(TARGETS ${plugin}
-add_executable(${exe} ${CMAKE_CURRENT_SOURCE_DIR}/runDDSCommandUI.cxx)
-target_link_libraries(${exe} FairMQ Commands SDK StateMachine)
-target_include_directories(${exe} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-
-install(TARGETS ${plugin} ${exe}
   EXPORT ${PROJECT_EXPORT_SET}
   LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
-  RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )

fairmq/plugins/DDS/DDS.cxx

@@ -344,10 +344,10 @@ auto DDS::HandleCmd(const string& id, sdk::cmd::Cmd& cmd, const string& cond, ui
         case Type::change_state: {
             Transition transition = static_cast<ChangeState&>(cmd).GetTransition();
             if (ChangeDeviceState(transition)) {
-                Cmds outCmds(make<TransitionStatus>(id, fDDSTaskId, Result::Ok, transition));
+                Cmds outCmds(make<TransitionStatus>(id, fDDSTaskId, Result::Ok, transition, GetCurrentDeviceState()));
                 fDDS.Send(outCmds.Serialize(), to_string(senderId));
             } else {
-                Cmds outCmds(make<TransitionStatus>(id, fDDSTaskId, Result::Failure, transition));
+                Cmds outCmds(make<TransitionStatus>(id, fDDSTaskId, Result::Failure, transition, GetCurrentDeviceState()));
                 fDDS.Send(outCmds.Serialize(), to_string(senderId));
             }
             {

fairmq/plugins/PMIx/PMIxPlugin.cxx

@@ -148,12 +148,12 @@ auto PMIxPlugin::SubscribeForCommands() -> void
                     Transition transition = static_cast<ChangeState&>(*cmd).GetTransition();
                     if (ChangeDeviceState(transition)) {
                         fCommands.Send(
-                            Cmds(make<TransitionStatus>(fDeviceId, 0, Result::Ok, transition))
+                            Cmds(make<TransitionStatus>(fDeviceId, 0, Result::Ok, transition, GetCurrentDeviceState()))
                                 .Serialize(Format::JSON),
                             {sender});
                     } else {
                         fCommands.Send(
-                            Cmds(make<TransitionStatus>(fDeviceId, 0, Result::Failure, transition))
+                            Cmds(make<TransitionStatus>(fDeviceId, 0, Result::Failure, transition, GetCurrentDeviceState()))
                                 .Serialize(Format::JSON),
                             {sender});
                     }

fairmq/plugins/config/Config.cxx

@@ -61,21 +61,26 @@ Plugin::ProgOptions ConfigPluginProgramOptions()
     namespace po = boost::program_options;
     auto pluginOptions = po::options_description{"FairMQ device options"};
     pluginOptions.add_options()
-        ("id",                po::value<string        >()->default_value(""),         "Device ID.")
+        ("id",                  po::value<string        >()->default_value(""),                "Device ID.")
-        ("io-threads",        po::value<int           >()->default_value(1),          "Number of I/O threads.")
+        ("io-threads",          po::value<int           >()->default_value(1),                 "Number of I/O threads.")
-        ("transport",         po::value<string        >()->default_value("zeromq"),   "Transport ('zeromq'/'nanomsg'/'shmem').")
+        ("transport",           po::value<string        >()->default_value("zeromq"),          "Transport ('zeromq'/'shmem').")
-        ("network-interface", po::value<string        >()->default_value("default"),  "Network interface to bind on (e.g. eth0, ib0..., default will try to detect the interface of the default route).")
+        ("network-interface",   po::value<string        >()->default_value("default"),         "Network interface to bind on (e.g. eth0, ib0..., default will try to detect the interface of the default route).")
-        ("init-timeout",      po::value<int           >()->default_value(120),        "Timeout for the initialization in seconds (when expecting dynamic initialization).")
+        ("init-timeout",        po::value<int           >()->default_value(120),               "Timeout for the initialization in seconds (when expecting dynamic initialization).")
-        ("max-run-time",      po::value<uint64_t      >()->default_value(0),          "Maximum runtime for the Running state handler, after which state will change to Ready (in seconds, 0 for no limit).")
+        ("max-run-time",        po::value<uint64_t      >()->default_value(0),                 "Maximum runtime for the Running state handler, after which state will change to Ready (in seconds, 0 for no limit).")
-        ("print-channels",    po::value<bool          >()->implicit_value(true),      "Print registered channel endpoints in a machine-readable format (<channel name>:<min num subchannels>:<max num subchannels>)")
+        ("print-channels",      po::value<bool          >()->implicit_value(true),             "Print registered channel endpoints in a machine-readable format (<channel name>:<min num subchannels>:<max num subchannels>)")
-        ("shm-segment-size",  po::value<size_t        >()->default_value(2000000000), "Shared memory: size of the shared memory segment (in bytes).")
+        ("shm-segment-size",    po::value<size_t        >()->default_value(2ULL << 30),        "Shared memory: size of the shared memory segment (in bytes).")
-        ("shm-monitor",       po::value<bool          >()->default_value(true),       "Shared memory: run monitor daemon.")
+        ("shm-allocation",      po::value<string        >()->default_value("rbtree_best_fit"), "Shared memory allocation algorithm: rbtree_best_fit/simple_seq_fit.")
-        ("ofi-size-hint",     po::value<size_t        >()->default_value(0),          "EXPERIMENTAL: OFI size hint for the allocator.")
+        ("shm-segment-id",      po::value<uint16_t      >()->default_value(0),                 "EXPERIMENTAL: Shared memory segment id for message creation.")
-        ("rate",              po::value<float         >()->default_value(0.),         "Rate for conditional run loop (Hz).")
+        ("shm-mlock-segment",   po::value<bool          >()->default_value(false),             "Shared memory: mlock the shared memory segment after initialization.")
-        ("session",           po::value<string        >()->default_value("default"),  "Session name.")
+        ("shm-zero-segment",    po::value<bool          >()->default_value(false),             "Shared memory: zero the shared memory segment memory after initialization.")
-        ("config-key",        po::value<string        >(),                            "Use provided value instead of device id for fetching the configuration from JSON file.")
+        ("shm-throw-bad-alloc", po::value<bool          >()->default_value(true),              "Throw a fair::mq::MessageBadAlloc if cannot allocate a message (retry if false).")
-        ("mq-config",         po::value<string        >(),                            "JSON input as file.")
+        ("shm-monitor",         po::value<bool          >()->default_value(true),              "Shared memory: run monitor daemon.")
-        ("channel-config",    po::value<vector<string>>()->multitoken()->composing(), "Configuration of single or multiple channel(s) by comma separated key=value list");
+        ("ofi-size-hint",       po::value<size_t        >()->default_value(0),                 "EXPERIMENTAL: OFI size hint for the allocator.")
+        ("rate",                po::value<float         >()->default_value(0.),                "Rate for conditional run loop (Hz).")
+        ("session",             po::value<string        >()->default_value("default"),         "Session name.")
+        ("config-key",          po::value<string        >(),                                   "Use provided value instead of device id for fetching the configuration from JSON file.")
+        ("mq-config",           po::value<string        >(),                                   "JSON input as file.")
+        ("channel-config",      po::value<vector<string>>()->multitoken()->composing(),        "Configuration of single or multiple channel(s) by comma separated key=value list");
     return pluginOptions;
 }
 

fairmq/run/runBenchmarkSampler.cxx

@@ -15,10 +15,11 @@ 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");
 }