Fix race condition in the control plugin

2025-10-15 17:41:45 +00:00 · 2018-09-12 16:14:32 +02:00
45 changed files with 673 additions and 5056 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,33 +0,0 @@
---
-Language: Cpp
-BasedOnStyle: Mozilla
-
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: true
-AllowShortFunctionsOnASingleLine: true
-AllowShortIfStatementsOnASingleLine: false
-AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlwaysBreakAfterReturnType: None
-AlwaysBreakAfterDefinitionReturnType: None
-BinPackArguments: false
-BinPackParameters: false
-BreakBeforeBinaryOperators: NonAssignment
-BreakConstructorInitializers: BeforeComma
-ColumnLimit: 100
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: true
-FixNamespaceComments: true
-IndentWidth: 4
-IndentWrappedFunctionNames: true
-IncludeBlocks: Regroup
-NamespaceIndentation: None
-PointerAlignment: Left
-SortIncludes: true
-SpacesBeforeTrailingComments: 3
-Standard: Cpp11
-UseTab: Never
-...
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,27 +0,0 @@
---
-name: Bug report
-about: Create a report to help us improve
-
---
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Describe environment
-2. Describe compile options used
-3. Give commands you invoked
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**System information (please complete the following information):**
- - OS: [e.g. MacOS, Fedora28, Ubuntu14.04]
- - Environment: [e.g. FairSoft version, alfadist revision]
-
-**Additional context**
-Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,17 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-
---
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@@ -1,7 +0,0 @@
---
-name: Question / Support
-about: Any FairMQ related matter you are interested in
-
---
-
-
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,30 +34,10 @@ cmake_dependent_option(BUILD_OFI_TRANSPORT "Build experimental OFI transport." O
 cmake_dependent_option(BUILD_DDS_PLUGIN "Build DDS plugin." OFF "BUILD_FAIRMQ" OFF)
 cmake_dependent_option(BUILD_EXAMPLES "Build FairMQ examples." ON "BUILD_FAIRMQ" OFF)
 option(BUILD_DOCS "Build FairMQ documentation." OFF)
-option(FAST_BUILD "Fast production build. Not recommended for development." OFF)
 ################################################################################


 # Dependencies #################################################################
-if(FAST_BUILD)
-  include(cotire)
-endif()
-
-macro(find_msgpack)
-  if(NOT msgpack_FOUND)
-    find_package2(PRIVATE msgpack VERSION 3.0.0)
-    set(PROJECT_msgpack_VERSION 2.1.5)
-    if(NOT msgpack_FOUND)
-      find_package2(PRIVATE msgpack VERSION 2.1.5 REQUIRED)
-    endif()
-    set(msgpack_ROOT ${PACKAGE_PREFIX_DIR})
-  endif()
-endmacro()
-
-set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-set(THREADS_PREFER_PTHREAD_FLAG TRUE)
-find_package(Threads REQUIRED)
-
 if(BUILD_FAIRMQ)
  find_package2(PUBLIC Boost VERSION 1.64 REQUIRED
    COMPONENTS program_options thread system filesystem regex date_time signals
@@ -186,29 +166,6 @@ install_cmake_package()


 # Summary ######################################################################
-if(CMAKE_CXX_FLAGS)
-  message(STATUS "  ")
-  message(STATUS "  ${Cyan}GLOBAL CXX FLAGS${CR}  ${BGreen}${CMAKE_CXX_FLAGS}${CR}")
-endif()
-if(CMAKE_CONFIGURATION_TYPES)
-  message(STATUS "  ")
-  message(STATUS "  ${Cyan}BUILD TYPE         CXX FLAGS${CR}")
-  string(TOUPPER "${CMAKE_BUILD_TYPE}" selected_type)
-  foreach(type IN LISTS CMAKE_CONFIGURATION_TYPES)
-    string(TOUPPER "${type}" type_upper)
-    if(type_upper STREQUAL selected_type)
-      pad("${type}" 18 " " type_padded)
-      message(STATUS "${BGreen}* ${type_padded}${CMAKE_CXX_FLAGS_${type_upper}}${CR}")
-    else()
-      pad("${type}" 18 " " type_padded)
-      message(STATUS "  ${BWhite}${type_padded}${CR}${CMAKE_CXX_FLAGS_${type_upper}}")
-    endif()
-    unset(type_padded)
-    unset(type_upper)
-  endforeach()
-  message(STATUS "  ")
-  message(STATUS "  (Change the build type with ${BMagenta}-DCMAKE_BUILD_TYPE=...${CR})")
-endif()
 if(PROJECT_PACKAGE_DEPENDENCIES)
  message(STATUS "  ")
  message(STATUS "  ${Cyan}DEPENDENCY FOUND     VERSION                   PREFIX${CR}")
--- a/41
+++ b/41
@@ -1,41 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: FairMQ
-Upstream-Contact: Mohammad Al-Turany <m.al-turany@gsi.de>
-Source: https://github.com/FairRootGroup/FairMQ
-
-Files: *
-Copyright: 2012-2018, GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
-Copyright: 2012-2018, [see AUTHORS file]
-Copyright: 2012-2018, [see CONTRIBUTORS file]
-Comment: The copyright of individual contributors is documented in the
-  Git history.
-License: LGPL-3.0-only
-
-Files: cmake/cotire.cmake
-Copyright: 2012-2018 Sascha Kratky
-License: COTIRE
-
-License: LGPL-3.0-only
-  [see LICENSE file]
-
-License: COTIRE
-  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.
--- a/Dart.sh
+++ b/Dart.sh
@@ -41,15 +41,13 @@ if [ "$#" -lt "2" ]; then
 fi

 # test if a valid ctest model is defined
-case "$1" in
-  Experimental|Nightly|Continuous|Profile|alfa_ci|codecov)
-    ;;
-  *)
-    echo "-- Error -- This ctest model is not supported."
-    echo "-- Error -- Possible arguments are Nightly, Experimental, Continuous or Profile."
-    exit 1
-    ;;
-esac
+if [ "$1" == "Experimental" -o "$1" == "Nightly" -o "$1" == "Continuous" -o "$1" == "Profile" -o "$1" == "alfa_ci" ]; then
+  echo ""
+else
+  echo "-- Error -- This ctest model is not supported."
+  echo "-- Error -- Possible arguments are Nightly, Experimental, Continuous or Profile."
+  exit 1
+fi

 # test if the input file exists and execute it
 if [ -e "$2" ];then
@@ -63,9 +61,6 @@ fi
 # set the ctest model to command line parameter
 if [ "$1" == "alfa_ci" ]; then
  export ctest_model=Experimental
-elif [ "$1" == "codecov" ]; then
-  export ctest_model=Profile
-  export do_codecov_upload=1
 else
  export ctest_model=$1
 fi
@@ -88,20 +83,13 @@ else
  COMPILER=$CXX$($CXX -dumpversion)
 fi

-case "$1" in
-  alfa_ci)
-    export LABEL1=alfa_ci-$COMPILER-FairMQ_$GIT_BRANCH
-    export LABEL=$(echo $LABEL1 | sed -e 's#/#_#g')
-    ;;
-  codecov)
-    export LABEL1=codecov-$COMPILER-FairMQ_$GIT_BRANCH
-    export LABEL=$(echo $LABEL1 | sed -e 's#/#_#g')
-    ;;
-  *)
-    export LABEL1=${LINUX_FLAVOUR}-$chip-$COMPILER-FairMQ_$GIT_BRANCH
-    export LABEL=$(echo $LABEL1 | sed -e 's#/#_#g')
-    ;;
-esac
+if [ "$1" == "alfa_ci" ]; then
+  export LABEL1=alfa_ci-$COMPILER-FairMQ_$GIT_BRANCH
+  export LABEL=$(echo $LABEL1 | sed -e 's#/#_#g')
+else
+  export LABEL1=${LINUX_FLAVOUR}-$chip-$COMPILER-FairMQ_$GIT_BRANCH
+  export LABEL=$(echo $LABEL1 | sed -e 's#/#_#g')
+fi

 # get the number of processors
 # and information about the host
--- a/FairMQTest.cmake
+++ b/FairMQTest.cmake
@@ -28,24 +28,24 @@ 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_DDS_PLUGIN=ON")
-Set(configure_options "${configure_options};-DFAST_BUILD=ON")
-Set(configure_options "${configure_options};-DCOTIRE_MAXIMUM_NUMBER_OF_UNITY_INCLUDES=-j$ENV{number_of_processors}")

 Set(EXTRA_FLAGS $ENV{EXTRA_FLAGS})
 If(EXTRA_FLAGS)
  Set(configure_options "${configure_options};${EXTRA_FLAGS}") 
 EndIf()

-If($ENV{ctest_model} MATCHES Profile)
+If($ENV{ctest_model} MATCHES Nightly OR $ENV{ctest_model} MATCHES Profile)
+
  Find_Program(GCOV_COMMAND gcov)
  If(GCOV_COMMAND)
    Message("Found GCOV: ${GCOV_COMMAND}")
    Set(CTEST_COVERAGE_COMMAND ${GCOV_COMMAND})
  EndIf(GCOV_COMMAND)
-EndIf()

-If($ENV{ctest_model} MATCHES Nightly OR $ENV{ctest_model} MATCHES Profile)
-  Ctest_Empty_Binary_Directory(${CTEST_BINARY_DIRECTORY})
+  Set(ENV{ctest_model} Nightly)
+
+  CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
+
 EndIf()

 Ctest_Start($ENV{ctest_model})
@@ -60,26 +60,9 @@ Ctest_Test(BUILD "${CTEST_BINARY_DIRECTORY}"
           PARALLEL_LEVEL $ENV{number_of_processors}
           RETURN_VALUE _ctest_test_ret_val
          )
-If("$ENV{do_codecov_upload}")
-  ForEach(i RANGE 4)
-    # Gather statistics to catch time sensitive branches
-    Ctest_Test(BUILD "${CTEST_BINARY_DIRECTORY}" 
-               PARALLEL_LEVEL $ENV{number_of_processors}
-              )
-  EndForEach()
-EndIf()

 If(GCOV_COMMAND)
-  Ctest_Coverage(BUILD "${CTEST_BINARY_DIRECTORY}" LABELS coverage)
-EndIf()
-
-If("$ENV{do_codecov_upload}")
-  Execute_Process(COMMAND curl https://codecov.io/bash -o codecov_uploader.sh
-                  WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY}
-                  TIMEOUT 60)
-  Execute_Process(COMMAND bash ./codecov_uploader.sh -X gcov
-                  WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY}
-                  TIMEOUT 60)
+  Ctest_Coverage(BUILD "${CTEST_BINARY_DIRECTORY}")
 EndIf()

 Ctest_Submit()
--- a/40
+++ b/40
@@ -4,31 +4,24 @@ def specToLabel(Map spec) {
  return "${spec.os}-${spec.arch}-${spec.compiler}-FairSoft_${spec.fairsoft}"
 }

-def jobMatrix(String prefix, List specs, Closure callback) {
+def buildMatrix(List specs, Closure callback) {
  def nodes = [:]
  for (spec in specs) {
    def label = specToLabel(spec)
-    nodes["${prefix}/${label}"] = {
+    nodes[label] = {
      node(label) {
-        githubNotify(context: "${prefix}/${label}", description: 'Building ...', status: 'PENDING')
+        githubNotify(context: "alfa-ci/${label}", description: 'Building ...', status: 'PENDING')
        try {
          deleteDir()
          checkout scm

-          sh '''\
-            echo "export BUILDDIR=$PWD/build" >> Dart.cfg
-            echo "export SOURCEDIR=$PWD" >> Dart.cfg
-            echo "export PATH=$SIMPATH/bin:$PATH" >> Dart.cfg
-            echo "export GIT_BRANCH=$JOB_BASE_NAME" >> Dart.cfg
-          '''
-
          callback.call(spec, label)

          deleteDir()
-          githubNotify(context: "${prefix}/${label}", description: 'Success', status: 'SUCCESS')
+          githubNotify(context: "alfa-ci/${label}", description: 'Success', status: 'SUCCESS')
        } catch (e) {
          deleteDir()
-          githubNotify(context: "${prefix}/${label}", description: 'Error', status: 'ERROR')
+          githubNotify(context: "alfa-ci/${label}", description: 'Error', status: 'ERROR')
          throw e
        }
      }
@@ -40,25 +33,22 @@ def jobMatrix(String prefix, List specs, Closure callback) {
 pipeline{
  agent none
  stages {
-    stage("Run CI Matrix") {
+    stage("Run Build/Test Matrix") {
      steps{
        script {
-          def build_jobs = jobMatrix('alfa-ci/build', [
+          parallel(buildMatrix([
            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc4.9',         fairsoft: 'may18'],
+            [os: 'MacOS10.11', arch: 'x86_64', compiler: 'AppleLLVM8.0.0', fairsoft: 'may18'],
            [os: 'MacOS10.13', arch: 'x86_64', compiler: 'AppleLLVM9.0.0', fairsoft: 'may18'],
          ]) { spec, label ->
+            sh '''\
+              echo "export BUILDDIR=$PWD/build" >> Dart.cfg
+              echo "export SOURCEDIR=$PWD" >> Dart.cfg
+              echo "export PATH=$SIMPATH/bin:$PATH" >> Dart.cfg
+              echo "export GIT_BRANCH=$JOB_BASE_NAME" >> Dart.cfg
+            '''
            sh './Dart.sh alfa_ci Dart.cfg'
-          }
-
-          def profile_jobs = jobMatrix('alfa-ci/codecov', [
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc4.9',         fairsoft: 'may18'],
-          ]) { spec, label ->
-            withCredentials([string(credentialsId: 'fairmq_codecov_token', variable: 'CODECOV_TOKEN')]) {
-              sh './Dart.sh codecov Dart.cfg'
-            }
-          }
-
-          parallel(build_jobs + profile_jobs)
+          })
        }
      }
    }
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,6 +1,4 @@
-Describe your proposal.
-
-Mention any issue this PR is resolves or is related to.
+Replace me with your description.

 ---

--- a/README.md
+++ b/README.md
@@ -1,14 +1,12 @@
 <!-- {#mainpage} -->
-# FairMQ [![license](https://alfa-ci.gsi.de/shields/github/license/FairRootGroup/FairMQ.svg)](COPYRIGHT)
+# FairMQ

-C++ Message Queuing Library and Framework
+C++ Message passing framework

-| Branch | Version | Docs | Status |
-| :---: | :--- | :--- | :--- |
-| `master` | [![release](https://alfa-ci.gsi.de/shields/github/release/FairRootGroup/FairMQ.svg)](https://github.com/FairRootGroup/FairMQ/releases/latest) | [API](https://fairrootgroup.github.io/FairMQ/latest), [Book](https://github.com/FairRootGroup/FairMQ/blob/master/README.md#documentation) | [![build status master branch](https://alfa-ci.gsi.de/buildStatus/icon?job=FairRootGroup/FairMQ/master)](https://alfa-ci.gsi.de/blue/organizations/jenkins/FairRootGroup%2FFairMQ/branches) [![test coverage master branch](https://codecov.io/gh/FairRootGroup/FairMQ/branch/master/graph/badge.svg)](https://codecov.io/gh/FairRootGroup/FairMQ/branch/master) |
-| `dev` | [![dev tag](https://alfa-ci.gsi.de/shields/github/tag/FairRootGroup/FairMQ.svg)](https://github.com/FairRootGroup/FairMQ/tags) | [Book](https://github.com/FairRootGroup/FairMQ/blob/dev/README.md#documentation) | [![build status dev branch](https://alfa-ci.gsi.de/buildStatus/icon?job=FairRootGroup/FairMQ/dev)](https://alfa-ci.gsi.de/blue/organizations/jenkins/FairRootGroup%2FFairMQ/branches) [![test coverage dev branch](https://codecov.io/gh/FairRootGroup/FairMQ/branch/dev/graph/badge.svg)](https://codecov.io/gh/FairRootGroup/FairMQ/branch/dev) |
-
-## Introduction
+| Branch | Build Status |
+| :---: | :--- |
+| `master` | ![build status master branch](https://alfa-ci.gsi.de/buildStatus/icon?job=FairRootGroup/FairMQ/master) |
+| `dev` | ![build status dev branch](https://alfa-ci.gsi.de/buildStatus/icon?job=FairRootGroup/FairMQ/dev) |

 FairMQ is designed to help implementing large-scale data processing workflows needed in next-generation Particle Physics experiments. FairMQ is written in C++ and aims to
  * provide **an asynchronous message passing abstraction** of different data transport technologies,
@@ -31,17 +29,32 @@ configuration and control services.
 FairMQ has been developed in the context of its mother project [FairRoot](https://github.com/FairRootGroup/FairRoot) -
 a simulation, reconstruction and analysis framework.

-Find all FairMQ releases and development tags [here](https://github.com/FairRootGroup/FairMQ/releases).
-
 ## Dependencies

-  * PUBLIC: [**Boost**](https://www.boost.org/), [**FairLogger**](https://github.com/FairRootGroup/FairLogger)
-  * BUILD: [CMake](https://cmake.org/), [GTest](https://github.com/google/googletest), [Doxygen](http://www.doxygen.org/)
-  * PRIVATE: [ZeroMQ](http://zeromq.org/), [Msgpack](https://msgpack.org/index.html), [nanomsg](http://nanomsg.org/),
-[OFI](https://ofiwg.github.io/libfabric/), [Protobuf](https://developers.google.com/protocol-buffers/), [DDS](http://dds.gsi.de)
+  * [**Boost**](https://www.boost.org/) (PUBLIC)
+  * [**FairLogger**](https://github.com/FairRootGroup/FairLogger) (PUBLIC)
+  * [CMake](https://cmake.org/) (BUILD)
+  * [GTest](https://github.com/google/googletest) (BUILD, optional, `tests`)
+  * [Doxygen](http://www.doxygen.org/) (BUILD, optional, `docs`)
+  * [ZeroMQ](http://zeromq.org/) (PRIVATE)
+  * [Msgpack](https://msgpack.org/index.html) (PRIVATE, optional, `nanomsg_transport`)
+  * [nanomsg](http://nanomsg.org/) (PRIVATE, optional, `nanomsg_transport`)
+  * [OFI](https://ofiwg.github.io/libfabric/) (PRIVATE, optional, `ofi_transport`)
+  * [Protobuf](https://developers.google.com/protocol-buffers/) (PRIVATE, optional, `ofi_transport`)
+  * [DDS](http://dds.gsi.de) (PRIVATE, optional, `dds_plugin`)

  Supported platforms: Linux and MacOS.

+## Releases
+
+| Stable release | Date | API Docs |
+| --- | --- | --- |
+| [**1.2.3**](https://github.com/FairRootGroup/FairMQ/releases/tag/v1.2.3) | May 2018 | [link](https://fairrootgroup.github.io/FairMQ/v1.2.3/index.html) |
+| [**1.2.1**](https://github.com/FairRootGroup/FairMQ/releases/tag/v1.2.1) | May 2018 | [link](https://fairrootgroup.github.io/FairMQ/v1.2.1/index.html) |
+| [**1.2.0**](https://github.com/FairRootGroup/FairMQ/releases/tag/v1.2.0) | May 2018 | [link](https://fairrootgroup.github.io/FairMQ/v1.2.0/index.html) |
+
+Find all FairMQ stable and development releases [here](https://github.com/FairRootGroup/FairMQ/releases).
+
 ## Installation from Source

 ```bash
@@ -76,7 +89,7 @@ In order to succesfully compile and link against the `FairMQ::FairMQ` target, yo
 find_package(FairMQ)
 if(FairMQ_FOUND)
  find_package(FairLogger ${FairMQ_FairLogger_VERSION})
-  find_package(Boost ${FairMQ_Boost_VERSION} COMPONENTS ${FairMQ_Boost_COMPONENTS})
+  find_package(Boost ${FairMQ_Boost_VERSION} COMPONENTS ${FairMQ_BOOST_COMPONENTS})
 endif()
 ```

@@ -88,7 +101,7 @@ Optionally, you can require certain FairMQ package components and a minimum vers
 find_package(FairMQ 1.1.0 COMPONENTS nanomsg_transport dds_plugin)
 if(FairMQ_FOUND)
  find_package(FairLogger ${FairMQ_FairLogger_VERSION})
-  find_package(Boost ${FairMQ_Boost_VERSION} COMPONENTS ${FairMQ_Boost_COMPONENTS})
+  find_package(Boost ${FairMQ_Boost_VERSION} COMPONENTS ${FairMQ_BOOST_COMPONENTS})
 endif()
 ```

@@ -156,3 +169,9 @@ After the `find_package(FairMQ)` call the following CMake variables are defined:
   4. [File output](docs/Logging.md#54-file-output)
   5. [Custom sinks](docs/Logging.md#55-custom-sinks)
 6. [Examples](docs/Examples.md#6-examples)
+
+## License
+
+GNU Lesser General Public Licence (LGPL) version 3, see [LICENSE](LICENSE).
+
+Copyright (C) 2013-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
--- a/cmake/FairMQLib.cmake
+++ b/cmake/FairMQLib.cmake
@@ -112,6 +112,7 @@ macro(set_fairmq_defaults)
    set(CMAKE_BUILD_TYPE RelWithDebInfo)
  endif()

+
  # Handle C++ standard level
  set(CMAKE_CXX_STANDARD_REQUIRED ON)
  if(NOT CMAKE_CXX_STANDARD)
@@ -157,23 +158,9 @@ macro(set_fairmq_defaults)
  # Define export set, only one for now
  set(PROJECT_EXPORT_SET ${PROJECT_NAME}Targets)

-  # Configure build types
-  set(CMAKE_CONFIGURATION_TYPES "Debug" "Release" "RelWithDebInfo" "Nightly" "Profile" "AdressSan" "ThreadSan")
-  set(CMAKE_CXX_FLAGS_DEBUG          "-g -Wshadow -Wall -Wextra")
-  set(CMAKE_CXX_FLAGS_RELEASE        "-O2 -DNDEBUG")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -Wshadow -Wall -Wextra -DNDEBUG")
-  set(CMAKE_CXX_FLAGS_NIGHTLY        "-O2 -g -Wshadow -Wall -Wextra")
-  set(CMAKE_CXX_FLAGS_PROFILE        "-g3 -Wshadow -Wall -Wextra -fno-inline -ftest-coverage -fprofile-arcs")
-  set(CMAKE_CXX_FLAGS_ADRESSSAN      "-O2 -g -Wshadow -Wall -Wextra -fsanitize=address -fno-omit-frame-pointer")
-  set(CMAKE_CXX_FLAGS_THREADSAN      "-O2 -g -Wshadow -Wall -Wextra -fsanitize=thread")
-
-  if(CMAKE_GENERATOR STREQUAL "Ninja" AND
-     ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9) OR
-      (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)))
-    # Force colored warnings in Ninja's output, if the compiler has -fdiagnostics-color support.
-    # Rationale in https://github.com/ninja-build/ninja/issues/814
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always")
-  endif()
+  # Override CMake defaults
+  set(CMAKE_CXX_FLAGS_NIGHTLY "-O2 -g -Wshadow -Wall -Wextra")
+  set(CMAKE_CXX_FLAGS_PROFILE "-g3 -fno-inline -ftest-coverage -fprofile-arcs -Wshadow -Wall -Wextra -Wunused-variable")
 endmacro()

 function(join VALUES GLUE OUTPUT)
@@ -250,7 +237,7 @@ endfunction()
 macro(install_cmake_package)
  include(CMakePackageConfigHelpers)
  set(PACKAGE_INSTALL_DESTINATION
-    ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}-${PROJECT_GIT_VERSION}
+    ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
  )
  if(BUILD_FAIRMQ)
    install(EXPORT ${PROJECT_EXPORT_SET}
--- a/cmake/Findmsgpack.cmake
+++ b/cmake/Findmsgpack.cmake
@@ -1,46 +0,0 @@
-################################################################################
-#    Copyright (C) 2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    #
-#                                                                              #
-#              This software is distributed under the terms of the             #
-#              GNU Lesser General Public Licence (LGPL) version 3,             #
-#                  copied verbatim in the file "LICENSE"                       #
-################################################################################
-
-unset(_args)
-
-if(msgpack_FIND_VERSION)
-  list(APPEND _args ${msgpack_FIND_VERSION})
-endif()
-
-if(msgpack_FIND_EXACT)
-  list(APPEND _args "EXACT")
-endif()
-
-if(msgpack_FIND_QUIETLY)
-  list(APPEND _args "QUIET")
-endif()
-
-if(msgpack_FIND_REQUIRED)
-  list(APPEND _args "REQUIRED")
-endif()
-
-if(msgpack_FIND_COMPONENTS)
-  list(APPEND _args "COMPONENTS" ${msgpack_FIND_COMPONENTS})
-endif()
-
-find_package(msgpack ${_args} CONFIG)
-
-if(msgpack_FOUND AND NOT TARGET msgpack::msgpack)
-  # config mode find_package does not set $msgpack_ROOT, workaround by extracting
-  # root path from library target
-  unset(_msgpack_lib)
-  unset(_prefix)
-  get_target_property(_msgpack_lib msgpackc INTERFACE_LOCATION)
-  get_filename_component(_prefix ${_msgpack_lib} DIRECTORY)
-  get_filename_component(_prefix ${_prefix}/.. ABSOLUTE)
-
-  add_library(msgpack::msgpack INTERFACE IMPORTED)
-  set_target_properties(msgpack::msgpack PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "${_prefix}/include"
-  )
-endif()
--- a/cmake/cotire.cmake
+++ b/cmake/cotire.cmake
--- a/fairmq/.clang-format
+++ b/fairmq/.clang-format
@@ -0,0 +1,54 @@
+---
+Language:        Cpp
+#AccessModifierOffset: -4
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+
+# It is broken on windows. Breaks all #include "header.h"
+#AlwaysBreakBeforeMultilineStrings: true
+
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: true
+BinPackParameters: false
+ColumnLimit: 160
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+DerivePointerBinding: false
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerBindsToType: true
+SpacesBeforeTrailingComments: 1
+Cpp11BracedListStyle: false
+Standard:        Cpp11
+IndentWidth:     4
+TabWidth:        4
+UseTab:          Never
+BreakBeforeBraces: Allman
+IndentFunctionDeclarationAfterType: true
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+CommentPragmas:  '^ IWYU pragma:'
+SpaceBeforeParens: ControlStatements
+...
--- a/fairmq/CMakeLists.txt
+++ b/fairmq/CMakeLists.txt
@@ -191,25 +191,16 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/options/startConfigExample.sh.in ${CM
 #################################
 # define libFairMQ build target #
 #################################
-if(FAST_BUILD)
-  set(_target FairMQ_)
-else()
-  set(_target FairMQ)
-endif()
-add_library(${_target} SHARED
+add_library(FairMQ SHARED
  ${FAIRMQ_SOURCE_FILES}
  ${FAIRMQ_PUBLIC_HEADER_FILES} # for IDE integration
  ${FAIRMQ_PRIVATE_HEADER_FILES} # for IDE integration
 )
-set_target_properties(${_target} PROPERTIES LABELS coverage)
-if(FAST_BUILD)
-  set_target_properties(${_target} PROPERTIES OUTPUT_NAME FairMQ)
-endif()

 #######################
 # include directories #
 #######################
-target_include_directories(${_target}
+target_include_directories(FairMQ
    PUBLIC # consumers inherit public include directories
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
@@ -222,21 +213,15 @@ target_include_directories(${_target}
 # link libraries #
 ##################
 if(BUILD_NANOMSG_TRANSPORT)
-  set(NANOMSG_DEPS nanomsg msgpack::msgpack)
+  set(NANOMSG_DEPS nanomsg msgpackc)
 endif()
 if(BUILD_OFI_TRANSPORT)
  set(OFI_DEPS OFI::libfabric protobuf::libprotobuf $<TARGET_OBJECTS:OfiTransport>)
 endif()
-set(optional_deps ${NANOMSG_DEPS} ${OFI_DEPS})
-if(optional_deps)
-  list(REMOVE_DUPLICATES optional_deps)
-endif()
-
-target_link_libraries(${_target}
+target_link_libraries(FairMQ
    INTERFACE # only consumers link against interface dependencies

    PUBLIC # libFairMQ AND consumers of libFairMQ link aginst public dependencies
-    Threads::Threads
    dl
    Boost::boost
    Boost::program_options
@@ -253,30 +238,15 @@ target_link_libraries(${_target}
    ${NANOMSG_DEPS}
    ${OFI_DEPS}
 )
-set_target_properties(${_target} PROPERTIES
-  VERSION ${PROJECT_GIT_VERSION}
+set_target_properties(FairMQ PROPERTIES
+  VERSION ${PROJECT_VERSION}
  SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
 )

-
-##############
-# fast build #
-##############
-if(FAST_BUILD)
-  set_target_properties(${_target} PROPERTIES
-    COTIRE_UNITY_TARGET_NAME "FairMQ"
-    # COTIRE_ENABLE_PRECOMPILED_HEADER FALSE
-    EXCLUDE_FROM_ALL TRUE
-  )
-  cotire(${_target})
-  set_target_properties(FairMQ PROPERTIES EXCLUDE_FROM_ALL FALSE)
-  set_target_properties(FairMQ PROPERTIES LABELS coverage)
-endif()
-
-
 ###############
 # executables #
 ###############
+
 add_executable(fairmq-bsampler run/runBenchmarkSampler.cxx)
 target_link_libraries(fairmq-bsampler FairMQ)

@@ -304,12 +274,11 @@ target_link_libraries(fairmq-shmmonitor FairMQ)
 add_executable(fairmq-uuid-gen run/runUuidGenerator.cxx)
 target_link_libraries(fairmq-uuid-gen FairMQ)

-
 ###########
 # install #
 ###########
 install(
-    TARGETS
+    TARGETS # FairMQFull, tests are not installed
    FairMQ
    fairmq-bsampler
    fairmq-merger
@@ -321,8 +290,8 @@ install(
    fairmq-uuid-gen

    EXPORT ${PROJECT_EXPORT_SET}
-    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
    LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR}
 )

 # preserve relative path and prepend fairmq
--- a/fairmq/DeviceRunner.cxx
+++ b/fairmq/DeviceRunner.cxx
@@ -13,12 +13,11 @@
 using namespace fair::mq;

 DeviceRunner::DeviceRunner(int argc, char* const argv[])
-    : fRawCmdLineArgs(tools::ToStrVector(argc, argv, false))
-    , fConfig()
-    , fDevice(nullptr)
-    , fPluginManager(fRawCmdLineArgs)
-    , fEvents()
-{}
+: fRawCmdLineArgs{tools::ToStrVector(argc, argv, false)}
+, fPluginManager{PluginManager::MakeFromCommandLineOptions(fRawCmdLineArgs)}
+, fDevice{nullptr}
+{
+}

 auto DeviceRunner::Run() -> int
 {
@@ -27,16 +26,16 @@ auto DeviceRunner::Run() -> int
    ////////////////////////

    // Load builtin plugins last
-    fPluginManager.LoadPlugin("s:control");
+    fPluginManager->LoadPlugin("s:control");

    ////// CALL HOOK ///////
    fEvents.Emit<hooks::SetCustomCmdLineOptions>(*this);
    ////////////////////////

-    fPluginManager.ForEachPluginProgOptions([&](boost::program_options::options_description options){
+    fPluginManager->ForEachPluginProgOptions([&](boost::program_options::options_description options){
        fConfig.AddToCmdLineOptions(options);
    });
-    fConfig.AddToCmdLineOptions(fPluginManager.ProgramOptions());
+    fConfig.AddToCmdLineOptions(fPluginManager->ProgramOptions());

    ////// CALL HOOK ///////
    fEvents.Emit<hooks::ModifyRawCmdLineArgs>(*this);
@@ -83,16 +82,13 @@ auto DeviceRunner::Run() -> int
    fDevice->SetConfig(fConfig);

    // Initialize plugin services
-    fPluginManager.EmplacePluginServices(fConfig, *fDevice);
+    fPluginManager->EmplacePluginServices(&fConfig, fDevice);

    // Instantiate and run plugins
-    fPluginManager.InstantiatePlugins();
-
-    // Run the device
-    fDevice->RunStateMachine();
+    fPluginManager->InstantiatePlugins();

    // Wait for control plugin to release device control
-    fPluginManager.WaitForPluginsToReleaseDeviceControl();
+    fPluginManager->WaitForPluginsToReleaseDeviceControl();

    return 0;
 }
--- a/fairmq/DeviceRunner.h
+++ b/fairmq/DeviceRunner.h
@@ -62,9 +62,9 @@ class DeviceRunner
    auto RemoveHook() -> void { fEvents.Unsubscribe<H>("runner"); }

    std::vector<std::string> fRawCmdLineArgs;
+    std::shared_ptr<PluginManager> fPluginManager;
    FairMQProgOptions fConfig;
-    std::unique_ptr<FairMQDevice> fDevice;
-    PluginManager fPluginManager;
+    std::shared_ptr<FairMQDevice> fDevice;

  private:
    EventManager fEvents;
--- a/fairmq/FairMQChannel.cxx
+++ b/fairmq/FairMQChannel.cxx
@@ -755,7 +755,7 @@ void FairMQChannel::CheckSendCompatibility(FairMQMessagePtr& msg) const
        // LOG(debug) << "Channel type does not match message type. Creating wrapper";
        FairMQMessagePtr msgWrapper(NewMessage(msg->GetData(),
                                               msg->GetSize(),
-                                               [](void* /*data*/, void* _msg) { delete static_cast<FairMQMessage*>(_msg); },
+                                               [](void* /*data*/, void* msg) { delete static_cast<FairMQMessage*>(msg); },
                                               msg.get()
                                               ));
        msg.release();
@@ -772,7 +772,7 @@ void FairMQChannel::CheckSendCompatibility(vector<FairMQMessagePtr>& msgVec) con
            // LOG(debug) << "Channel type does not match message type. Creating wrapper";
            FairMQMessagePtr msgWrapper(NewMessage(msg->GetData(),
                                                   msg->GetSize(),
-                                                   [](void* /*data*/, void* _msg) { delete static_cast<FairMQMessage*>(_msg); },
+                                                   [](void* /*data*/, void* msg) { delete static_cast<FairMQMessage*>(msg); },
                                                   msg.get()
                                                   ));
            msg.release();
--- a/fairmq/FairMQDevice.h
+++ b/fairmq/FairMQDevice.h
@@ -416,8 +416,6 @@ class FairMQDevice : public FairMQStateMachine
    void SetRawCmdLineArgs(const std::vector<std::string>& args) { fRawCmdLineArgs = args; }
    std::vector<std::string> GetRawCmdLineArgs() const { return fRawCmdLineArgs; }

-    void RunStateMachine() { ProcessWork(); };
-
  protected:
    std::shared_ptr<FairMQTransportFactory> fTransportFactory; ///< Default transport factory
    std::unordered_map<fair::mq::Transport, std::shared_ptr<FairMQTransportFactory>> fTransports; ///< Container for transports
--- a/fairmq/FairMQStateMachine.cxx
+++ b/fairmq/FairMQStateMachine.cxx
@@ -13,7 +13,6 @@
 */

 #include "FairMQStateMachine.h"
-#include <fairmq/Tools.h>

 // Increase maximum number of boost::msm states (default is 10)
 // This #define has to be before any msm header includes
@@ -30,20 +29,13 @@

 #include <atomic>
 #include <condition_variable>
+#include <thread>
 #include <chrono>
-#include <array>
 #include <unordered_map>

 using namespace std;
-using namespace boost::msm::front;

-namespace std
-{
-
-template<>
-struct hash<FairMQStateMachine::Event> : fair::mq::tools::HashEnum<FairMQStateMachine::Event> {};
-
-} /* namespace std */
+namespace msmf = boost::msm::front;

 namespace fair
 {
@@ -52,111 +44,35 @@ namespace mq
 namespace fsm
 {

-// list of FSM states
-struct OK_FSM_STATE                  : public state<> { static string Name() { return "OK"; }                  static FairMQStateMachine::State Type() { return FairMQStateMachine::State::OK; } };
-struct ERROR_FSM_STATE               : public terminate_state<> { static string Name() { return "ERROR"; }     static FairMQStateMachine::State Type() { return FairMQStateMachine::State::Error; } };
+// defining events for the boost MSM state machine
+struct INIT_DEVICE_E           { string name() const { return "INIT_DEVICE"; } };
+struct internal_DEVICE_READY_E { string name() const { return "internal_DEVICE_READY"; } };
+struct INIT_TASK_E             { string name() const { return "INIT_TASK"; } };
+struct internal_READY_E        { string name() const { return "internal_READY"; } };
+struct RUN_E                   { string name() const { return "RUN"; } };
+struct PAUSE_E                 { string name() const { return "PAUSE"; } };
+struct STOP_E                  { string name() const { return "STOP"; } };
+struct RESET_TASK_E            { string name() const { return "RESET_TASK"; } };
+struct RESET_DEVICE_E          { string name() const { return "RESET_DEVICE"; } };
+struct internal_IDLE_E         { string name() const { return "internal_IDLE"; } };
+struct END_E                   { string name() const { return "END"; } };
+struct ERROR_FOUND_E           { string name() const { return "ERROR_FOUND"; } };

-struct IDLE_FSM_STATE                : public state<> { static string Name() { return "IDLE"; }                static FairMQStateMachine::State Type() { return FairMQStateMachine::State::IDLE; } };
-struct INITIALIZING_DEVICE_FSM_STATE : public state<> { static string Name() { return "INITIALIZING_DEVICE"; } static FairMQStateMachine::State Type() { return FairMQStateMachine::State::INITIALIZING_DEVICE; } };
-struct DEVICE_READY_FSM_STATE        : public state<> { static string Name() { return "DEVICE_READY"; }        static FairMQStateMachine::State Type() { return FairMQStateMachine::State::DEVICE_READY; } };
-struct INITIALIZING_TASK_FSM_STATE   : public state<> { static string Name() { return "INITIALIZING_TASK"; }   static FairMQStateMachine::State Type() { return FairMQStateMachine::State::INITIALIZING_TASK; } };
-struct READY_FSM_STATE               : public state<> { static string Name() { return "READY"; }               static FairMQStateMachine::State Type() { return FairMQStateMachine::State::READY; } };
-struct RUNNING_FSM_STATE             : public state<> { static string Name() { return "RUNNING"; }             static FairMQStateMachine::State Type() { return FairMQStateMachine::State::RUNNING; } };
-struct PAUSED_FSM_STATE              : public state<> { static string Name() { return "PAUSED"; }              static FairMQStateMachine::State Type() { return FairMQStateMachine::State::PAUSED; } };
-struct RESETTING_TASK_FSM_STATE      : public state<> { static string Name() { return "RESETTING_TASK"; }      static FairMQStateMachine::State Type() { return FairMQStateMachine::State::RESETTING_TASK; } };
-struct RESETTING_DEVICE_FSM_STATE    : public state<> { static string Name() { return "RESETTING_DEVICE"; }    static FairMQStateMachine::State Type() { return FairMQStateMachine::State::RESETTING_DEVICE; } };
-struct EXITING_FSM_STATE             : public state<> { static string Name() { return "EXITING"; }             static FairMQStateMachine::State Type() { return FairMQStateMachine::State::EXITING; } };
-
-// list of FSM events
-struct INIT_DEVICE_FSM_EVENT           { static string Name() { return "INIT_DEVICE"; }           static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::INIT_DEVICE; } };
-struct internal_DEVICE_READY_FSM_EVENT { static string Name() { return "internal_DEVICE_READY"; } static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::internal_DEVICE_READY; } };
-struct INIT_TASK_FSM_EVENT             { static string Name() { return "INIT_TASK"; }             static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::INIT_TASK; } };
-struct internal_READY_FSM_EVENT        { static string Name() { return "internal_READY"; }        static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::internal_READY; } };
-struct RUN_FSM_EVENT                   { static string Name() { return "RUN"; }                   static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::RUN; } };
-struct PAUSE_FSM_EVENT                 { static string Name() { return "PAUSE"; }                 static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::PAUSE; } };
-struct STOP_FSM_EVENT                  { static string Name() { return "STOP"; }                  static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::STOP; } };
-struct RESET_TASK_FSM_EVENT            { static string Name() { return "RESET_TASK"; }            static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::RESET_TASK; } };
-struct RESET_DEVICE_FSM_EVENT          { static string Name() { return "RESET_DEVICE"; }          static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::RESET_DEVICE; } };
-struct internal_IDLE_FSM_EVENT         { static string Name() { return "internal_IDLE"; }         static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::internal_IDLE; } };
-struct END_FSM_EVENT                   { static string Name() { return "END"; }                   static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::END; } };
-struct ERROR_FOUND_FSM_EVENT           { static string Name() { return "ERROR_FOUND"; }           static FairMQStateMachine::Event Type() { return FairMQStateMachine::Event::ERROR_FOUND; } };
-
-static array<string, 12> stateNames =
-{
-    {
-        "OK",
-        "Error",
-        "IDLE",
-        "INITIALIZING_DEVICE",
-        "DEVICE_READY",
-        "INITIALIZING_TASK",
-        "READY",
-        "RUNNING",
-        "PAUSED",
-        "RESETTING_TASK",
-        "RESETTING_DEVICE",
-        "EXITING"
-    }
-};
-
-static array<string, 12> eventNames =
-{
-    {
-        "INIT_DEVICE",
-        "internal_DEVICE_READY",
-        "INIT_TASK",
-        "internal_READY",
-        "RUN",
-        "PAUSE",
-        "STOP",
-        "RESET_TASK",
-        "RESET_DEVICE",
-        "internal_IDLE",
-        "END",
-        "ERROR_FOUND"
-    }
-};
-
-static map<string, int> stateNumbers =
-{
-    { "OK",                  FairMQStateMachine::State::OK },
-    { "Error",               FairMQStateMachine::State::Error },
-    { "IDLE",                FairMQStateMachine::State::IDLE },
-    { "INITIALIZING_DEVICE", FairMQStateMachine::State::INITIALIZING_DEVICE },
-    { "DEVICE_READY",        FairMQStateMachine::State::DEVICE_READY },
-    { "INITIALIZING_TASK",   FairMQStateMachine::State::INITIALIZING_TASK },
-    { "READY",               FairMQStateMachine::State::READY },
-    { "RUNNING",             FairMQStateMachine::State::RUNNING },
-    { "PAUSED",              FairMQStateMachine::State::PAUSED },
-    { "RESETTING_TASK",      FairMQStateMachine::State::RESETTING_TASK },
-    { "RESETTING_DEVICE",    FairMQStateMachine::State::RESETTING_DEVICE },
-    { "EXITING",             FairMQStateMachine::State::EXITING }
-};
-
-static map<string, int> eventNumbers =
-{
-    { "INIT_DEVICE",           FairMQStateMachine::Event::INIT_DEVICE },
-    { "internal_DEVICE_READY", FairMQStateMachine::Event::internal_DEVICE_READY },
-    { "INIT_TASK",             FairMQStateMachine::Event::INIT_TASK },
-    { "internal_READY",        FairMQStateMachine::Event::internal_READY },
-    { "RUN",                   FairMQStateMachine::Event::RUN },
-    { "PAUSE",                 FairMQStateMachine::Event::PAUSE },
-    { "STOP",                  FairMQStateMachine::Event::STOP },
-    { "RESET_TASK",            FairMQStateMachine::Event::RESET_TASK },
-    { "RESET_DEVICE",          FairMQStateMachine::Event::RESET_DEVICE },
-    { "internal_IDLE",         FairMQStateMachine::Event::internal_IDLE },
-    { "END",                   FairMQStateMachine::Event::END },
-    { "ERROR_FOUND",           FairMQStateMachine::Event::ERROR_FOUND }
-};
+// deactivate the warning for non-virtual destructor thrown in the boost library
+#if defined(__clang__)
+_Pragma("clang diagnostic push")
+_Pragma("clang diagnostic ignored \"-Wnon-virtual-dtor\"")
+#elif defined(__GNUC__) || defined(__GNUG__)
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wnon-virtual-dtor\"")
+#endif

 // defining the boost MSM state machine
-struct Machine_ : public state_machine_def<Machine_>
+struct Machine_ : public msmf::state_machine_def<Machine_>
 {
  public:
    Machine_()
-        : fUnblockHandler()
-        , fStateHandlers()
-        , fWork()
+        : fWork()
        , fWorkAvailableCondition()
        , fWorkDoneCondition()
        , fWorkMutex()
@@ -165,22 +81,23 @@ struct Machine_ : public state_machine_def<Machine_>
        , fWorkAvailable(false)
        , fStateChangeSignal()
        , fStateChangeSignalsMap()
+        , fTerminationRequested(false)
        , fState()
+        , fWorkerThread()
    {}

    virtual ~Machine_()
    {}

-    // initial states
-    using initial_state = boost::mpl::vector<IDLE_FSM_STATE, OK_FSM_STATE>;
-
    template<typename Event, typename FSM>
    void on_entry(Event const&, FSM& fsm)
    {
        LOG(state) << "Starting FairMQ state machine";
        fState = FairMQStateMachine::IDLE;
-        LOG(state) << "Entering IDLE state";
        fsm.CallStateChangeCallbacks(FairMQStateMachine::IDLE);
+
+        // start a worker thread to execute user states in.
+        fsm.fWorkerThread = thread(&Machine_::Worker, &fsm);
    }

    template<typename Event, typename FSM>
@@ -189,23 +106,41 @@ struct Machine_ : public state_machine_def<Machine_>
        LOG(state) << "Exiting FairMQ state machine";
    }

+    // list of FSM states
+    struct OK_FSM                  : public msmf::state<> {};
+    struct ERROR_FSM               : public msmf::terminate_state<> {};
+
+    struct IDLE_FSM                : public msmf::state<> {};
+    struct INITIALIZING_DEVICE_FSM : public msmf::state<> {};
+    struct DEVICE_READY_FSM        : public msmf::state<> {};
+    struct INITIALIZING_TASK_FSM   : public msmf::state<> {};
+    struct READY_FSM               : public msmf::state<> {};
+    struct RUNNING_FSM             : public msmf::state<> {};
+    struct PAUSED_FSM              : public msmf::state<> {};
+    struct RESETTING_TASK_FSM      : public msmf::state<> {};
+    struct RESETTING_DEVICE_FSM    : public msmf::state<> {};
+    struct EXITING_FSM             : public msmf::state<> {};
+
+    // initial states
+    using initial_state = boost::mpl::vector<IDLE_FSM, OK_FSM>;
+
    // actions
-    struct AutomaticFct
+    struct IdleFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const&, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            fsm.fState = ts.Type();
-            LOG(state) << "Entering " << ts.Name() << " state";
+            LOG(state) << "Entering IDLE state";
+            fsm.fState = FairMQStateMachine::IDLE;
        }
    };

-    struct DefaultFct
+    struct InitDeviceFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const& e, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            fsm.fState = ts.Type();
+            fsm.fState = FairMQStateMachine::INITIALIZING_DEVICE;

            unique_lock<mutex> lock(fsm.fWorkMutex);
            while (fsm.fWorkActive)
@@ -213,8 +148,66 @@ struct Machine_ : public state_machine_def<Machine_>
                fsm.fWorkDoneCondition.wait(lock);
            }
            fsm.fWorkAvailable = true;
-            LOG(state) << "Entering " << ts.Name() << " state";
-            fsm.fWork = fsm.fStateHandlers.at(e.Type());
+            LOG(state) << "Entering INITIALIZING DEVICE state";
+            fsm.fWork = fsm.fInitWrapperHandler;
+            fsm.fWorkAvailableCondition.notify_one();
+        }
+    };
+
+    struct DeviceReadyFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            LOG(state) << "Entering DEVICE READY state";
+            fsm.fState = FairMQStateMachine::DEVICE_READY;
+        }
+    };
+
+    struct InitTaskFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            fsm.fState = FairMQStateMachine::INITIALIZING_TASK;
+
+            unique_lock<mutex> lock(fsm.fWorkMutex);
+            while (fsm.fWorkActive)
+            {
+                fsm.fWorkDoneCondition.wait(lock);
+            }
+            fsm.fWorkAvailable = true;
+            LOG(state) << "Entering INITIALIZING TASK state";
+            fsm.fWork = fsm.fInitTaskWrapperHandler;
+            fsm.fWorkAvailableCondition.notify_one();
+        }
+    };
+
+    struct ReadyFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            LOG(state) << "Entering READY state";
+            fsm.fState = FairMQStateMachine::READY;
+        }
+    };
+
+    struct RunFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            fsm.fState = FairMQStateMachine::RUNNING;
+
+            unique_lock<mutex> lock(fsm.fWorkMutex);
+            while (fsm.fWorkActive)
+            {
+                fsm.fWorkDoneCondition.wait(lock);
+            }
+            fsm.fWorkAvailable = true;
+            LOG(state) << "Entering RUNNING state";
+            fsm.fWork = fsm.fRunWrapperHandler;
            fsm.fWorkAvailableCondition.notify_one();
        }
    };
@@ -222,9 +215,9 @@ struct Machine_ : public state_machine_def<Machine_>
    struct PauseFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const&, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            fsm.fState = ts.Type();
+            fsm.fState = FairMQStateMachine::PAUSED;

            fsm.fUnblockHandler();
            unique_lock<mutex> lock(fsm.fWorkMutex);
@@ -233,18 +226,37 @@ struct Machine_ : public state_machine_def<Machine_>
                fsm.fWorkDoneCondition.wait(lock);
            }
            fsm.fWorkAvailable = true;
-            LOG(state) << "Entering " << ts.Name() << " state";
+            LOG(state) << "Entering PAUSED state";
            fsm.fWork = fsm.fPauseWrapperHandler;
            fsm.fWorkAvailableCondition.notify_one();
        }
    };

+    struct ResumeFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            fsm.fState = FairMQStateMachine::RUNNING;
+
+            unique_lock<mutex> lock(fsm.fWorkMutex);
+            while (fsm.fWorkActive)
+            {
+                fsm.fWorkDoneCondition.wait(lock);
+            }
+            fsm.fWorkAvailable = true;
+            LOG(state) << "Entering RUNNING state";
+            fsm.fWork = fsm.fRunWrapperHandler;
+            fsm.fWorkAvailableCondition.notify_one();
+        }
+    };
+
    struct StopFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const&, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            fsm.fState = ts.Type();
+            fsm.fState = FairMQStateMachine::READY;

            fsm.fUnblockHandler();
            unique_lock<mutex> lock(fsm.fWorkMutex);
@@ -252,70 +264,115 @@ struct Machine_ : public state_machine_def<Machine_>
            {
                fsm.fWorkDoneCondition.wait(lock);
            }
-            LOG(state) << "Entering " << ts.Name() << " state";
+            LOG(state) << "Entering READY state";
        }
    };

    struct InternalStopFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const&, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            fsm.fState = ts.Type();
+            fsm.fState = FairMQStateMachine::READY;
            fsm.fUnblockHandler();
-            LOG(state) << "RUNNING state finished without an external event, entering " << ts.Name() << " state";
+            LOG(state) << "RUNNING state finished without an external event, entering READY state";
+        }
+    };
+
+    struct ResetTaskFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            fsm.fState = FairMQStateMachine::RESETTING_TASK;
+
+            unique_lock<mutex> lock(fsm.fWorkMutex);
+            while (fsm.fWorkActive)
+            {
+                fsm.fWorkDoneCondition.wait(lock);
+            }
+            fsm.fWorkAvailable = true;
+            LOG(state) << "Entering RESETTING TASK state";
+            fsm.fWork = fsm.fResetTaskWrapperHandler;
+            fsm.fWorkAvailableCondition.notify_one();
+        }
+    };
+
+    struct ResetDeviceFct
+    {
+        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
+        {
+            fsm.fState = FairMQStateMachine::RESETTING_DEVICE;
+
+            unique_lock<mutex> lock(fsm.fWorkMutex);
+            while (fsm.fWorkActive)
+            {
+                fsm.fWorkDoneCondition.wait(lock);
+            }
+            fsm.fWorkAvailable = true;
+            LOG(state) << "Entering RESETTING DEVICE state";
+            fsm.fWork = fsm.fResetWrapperHandler;
+            fsm.fWorkAvailableCondition.notify_one();
        }
    };

    struct ExitingFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const& e, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            LOG(state) << "Entering " << ts.Name() << " state";
-            fsm.fState = ts.Type();
+            LOG(state) << "Entering EXITING state";
+            fsm.fState = FairMQStateMachine::EXITING;
+            fsm.fTerminationRequested = true;
            fsm.CallStateChangeCallbacks(FairMQStateMachine::EXITING);

-            // Stop ProcessWork()
+            // terminate worker thread
            {
                lock_guard<mutex> lock(fsm.fWorkMutex);
                fsm.fWorkerTerminated = true;
                fsm.fWorkAvailableCondition.notify_one();
            }

-            fsm.fStateHandlers.at(e.Type())();
+            // join the worker thread (executing user states)
+            if (fsm.fWorkerThread.joinable())
+            {
+                fsm.fWorkerThread.join();
+            }
+
+            fsm.fExitHandler();
        }
    };

    struct ErrorFoundFct
    {
        template<typename EVT, typename FSM, typename SourceState, typename TargetState>
-        void operator()(EVT const&, FSM& fsm, SourceState& /* ss */, TargetState& ts)
+        void operator()(EVT const&, FSM& fsm, SourceState&, TargetState&)
        {
-            fsm.fState = ts.Type();
-            LOG(state) << "Entering " << ts.Name() << " state";
+            LOG(state) << "Entering ERROR state";
+            fsm.fState = FairMQStateMachine::Error;
            fsm.CallStateChangeCallbacks(FairMQStateMachine::Error);
        }
    };

    // Transition table for Machine_
    struct transition_table : boost::mpl::vector<
-        // Start                           Event                            Next                           Action           Guard
-        Row<IDLE_FSM_STATE,                INIT_DEVICE_FSM_EVENT,           INITIALIZING_DEVICE_FSM_STATE, DefaultFct,      none>,
-        Row<IDLE_FSM_STATE,                END_FSM_EVENT,                   EXITING_FSM_STATE,             ExitingFct,      none>,
-        Row<INITIALIZING_DEVICE_FSM_STATE, internal_DEVICE_READY_FSM_EVENT, DEVICE_READY_FSM_STATE,        AutomaticFct,    none>,
-        Row<DEVICE_READY_FSM_STATE,        INIT_TASK_FSM_EVENT,             INITIALIZING_TASK_FSM_STATE,   DefaultFct,      none>,
-        Row<DEVICE_READY_FSM_STATE,        RESET_DEVICE_FSM_EVENT,          RESETTING_DEVICE_FSM_STATE,    DefaultFct,      none>,
-        Row<INITIALIZING_TASK_FSM_STATE,   internal_READY_FSM_EVENT,        READY_FSM_STATE,               AutomaticFct,    none>,
-        Row<READY_FSM_STATE,               RUN_FSM_EVENT,                   RUNNING_FSM_STATE,             DefaultFct,      none>,
-        Row<READY_FSM_STATE,               RESET_TASK_FSM_EVENT,            RESETTING_TASK_FSM_STATE,      DefaultFct,      none>,
-        Row<RUNNING_FSM_STATE,             PAUSE_FSM_EVENT,                 PAUSED_FSM_STATE,              DefaultFct,      none>,
-        Row<RUNNING_FSM_STATE,             STOP_FSM_EVENT,                  READY_FSM_STATE,               StopFct,         none>,
-        Row<RUNNING_FSM_STATE,             internal_READY_FSM_EVENT,        READY_FSM_STATE,               InternalStopFct, none>,
-        Row<PAUSED_FSM_STATE,              RUN_FSM_EVENT,                   RUNNING_FSM_STATE,             DefaultFct,      none>,
-        Row<RESETTING_TASK_FSM_STATE,      internal_DEVICE_READY_FSM_EVENT, DEVICE_READY_FSM_STATE,        AutomaticFct,    none>,
-        Row<RESETTING_DEVICE_FSM_STATE,    internal_IDLE_FSM_EVENT,         IDLE_FSM_STATE,                AutomaticFct,    none>,
-        Row<OK_FSM_STATE,                  ERROR_FOUND_FSM_EVENT,           ERROR_FSM_STATE,               ErrorFoundFct,   none>>
+        //        Start                    Event                    Next                     Action           Guard
+        msmf::Row<IDLE_FSM,                INIT_DEVICE_E,           INITIALIZING_DEVICE_FSM, InitDeviceFct,   msmf::none>,
+        msmf::Row<IDLE_FSM,                END_E,                   EXITING_FSM,             ExitingFct,      msmf::none>,
+        msmf::Row<INITIALIZING_DEVICE_FSM, internal_DEVICE_READY_E, DEVICE_READY_FSM,        DeviceReadyFct,  msmf::none>,
+        msmf::Row<DEVICE_READY_FSM,        INIT_TASK_E,             INITIALIZING_TASK_FSM,   InitTaskFct,     msmf::none>,
+        msmf::Row<DEVICE_READY_FSM,        RESET_DEVICE_E,          RESETTING_DEVICE_FSM,    ResetDeviceFct,  msmf::none>,
+        msmf::Row<INITIALIZING_TASK_FSM,   internal_READY_E,        READY_FSM,               ReadyFct,        msmf::none>,
+        msmf::Row<READY_FSM,               RUN_E,                   RUNNING_FSM,             RunFct,          msmf::none>,
+        msmf::Row<READY_FSM,               RESET_TASK_E,            RESETTING_TASK_FSM,      ResetTaskFct,    msmf::none>,
+        msmf::Row<RUNNING_FSM,             PAUSE_E,                 PAUSED_FSM,              PauseFct,        msmf::none>,
+        msmf::Row<RUNNING_FSM,             STOP_E,                  READY_FSM,               StopFct,         msmf::none>,
+        msmf::Row<RUNNING_FSM,             internal_READY_E,        READY_FSM,               InternalStopFct, msmf::none>,
+        msmf::Row<PAUSED_FSM,              RUN_E,                   RUNNING_FSM,             ResumeFct,       msmf::none>,
+        msmf::Row<RESETTING_TASK_FSM,      internal_DEVICE_READY_E, DEVICE_READY_FSM,        DeviceReadyFct,  msmf::none>,
+        msmf::Row<RESETTING_DEVICE_FSM,    internal_IDLE_E,         IDLE_FSM,                IdleFct,         msmf::none>,
+        msmf::Row<OK_FSM,                  ERROR_FOUND_E,           ERROR_FSM,               ErrorFoundFct,   msmf::none>>
    {};

    // replaces the default no-transition response.
@@ -334,12 +391,45 @@ struct Machine_ : public state_machine_def<Machine_>
        if (pos != string::npos)
        {
            stateName = stateName.substr(pos + 1);
-            stateName = stateName.substr(0, stateName.size() - 10);
+            stateName = stateName.substr(0, stateName.size() - 4);
        }

        if (stateName != "OK")
        {
-            LOG(state) << "No transition from state " << stateName << " on event " << e.Name();
+            LOG(state) << "No transition from state " << stateName << " on event " << e.name();
+        }
+    }
+
+    static string GetStateName(const int state)
+    {
+        switch(state)
+        {
+            case FairMQStateMachine::OK:
+                return "OK";
+            case FairMQStateMachine::Error:
+                return "Error";
+            case FairMQStateMachine::IDLE:
+                return "IDLE";
+            case FairMQStateMachine::INITIALIZING_DEVICE:
+                return "INITIALIZING_DEVICE";
+            case FairMQStateMachine::DEVICE_READY:
+                return "DEVICE_READY";
+            case FairMQStateMachine::INITIALIZING_TASK:
+                return "INITIALIZING_TASK";
+            case FairMQStateMachine::READY:
+                return "READY";
+            case FairMQStateMachine::RUNNING:
+                return "RUNNING";
+            case FairMQStateMachine::PAUSED:
+                return "PAUSED";
+            case FairMQStateMachine::RESETTING_TASK:
+                return "RESETTING_TASK";
+            case FairMQStateMachine::RESETTING_DEVICE:
+                return "RESETTING_DEVICE";
+            case FairMQStateMachine::EXITING:
+                return "EXITING";
+            default:
+                return "requested name for non-existent state...";
        }
    }

@@ -351,8 +441,14 @@ struct Machine_ : public state_machine_def<Machine_>
        }
    }

+    function<void(void)> fInitWrapperHandler;
+    function<void(void)> fInitTaskWrapperHandler;
+    function<void(void)> fRunWrapperHandler;
+    function<void(void)> fPauseWrapperHandler;
+    function<void(void)> fResetWrapperHandler;
+    function<void(void)> fResetTaskWrapperHandler;
+    function<void(void)> fExitHandler;
    function<void(void)> fUnblockHandler;
-    unordered_map<FairMQStateMachine::Event, function<void(void)>> fStateHandlers;

    // function to execute user states in a worker thread
    function<void(void)> fWork;
@@ -365,10 +461,12 @@ struct Machine_ : public state_machine_def<Machine_>

    boost::signals2::signal<void(const FairMQStateMachine::State)> fStateChangeSignal;
    unordered_map<string, boost::signals2::connection> fStateChangeSignalsMap;
+    atomic<bool> fTerminationRequested;

    atomic<FairMQStateMachine::State> fState;

-    void ProcessWork()
+  private:
+    void Worker()
    {
        while (true)
        {
@@ -377,7 +475,7 @@ struct Machine_ : public state_machine_def<Machine_>
                // Wait for work to be done.
                while (!fWorkAvailable && !fWorkerTerminated)
                {
-                    fWorkAvailableCondition.wait_for(lock, chrono::milliseconds(100));
+                    fWorkAvailableCondition.wait(lock);
                }

                if (fWorkerTerminated)
@@ -399,10 +497,20 @@ struct Machine_ : public state_machine_def<Machine_>
            CallStateChangeCallbacks(fState);
        }
    }
+
+    // run state handlers in a separate thread
+    thread fWorkerThread;
 }; // Machine_

 using FairMQFSM = boost::msm::back::state_machine<Machine_>;

+// reactivate the warning for non-virtual destructor
+#if defined(__clang__)
+_Pragma("clang diagnostic pop")
+#elif defined(__GNUC__) || defined(__GNUG__)
+_Pragma("GCC diagnostic pop")
+#endif
+
 } // namespace fsm
 } // namespace mq
 } // namespace fair
@@ -413,13 +521,13 @@ FairMQStateMachine::FairMQStateMachine()
    : fChangeStateMutex()
    , fFsm(new FairMQFSM)
 {
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(INIT_DEVICE, bind(&FairMQStateMachine::InitWrapper, this));
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(INIT_TASK, bind(&FairMQStateMachine::InitTaskWrapper, this));
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(RUN, bind(&FairMQStateMachine::RunWrapper, this));
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(PAUSE, bind(&FairMQStateMachine::PauseWrapper, this));
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(RESET_TASK, bind(&FairMQStateMachine::ResetTaskWrapper, this));
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(RESET_DEVICE, bind(&FairMQStateMachine::ResetWrapper, this));
-    static_pointer_cast<FairMQFSM>(fFsm)->fStateHandlers.emplace(END, bind(&FairMQStateMachine::Exit, this));
+    static_pointer_cast<FairMQFSM>(fFsm)->fInitWrapperHandler = bind(&FairMQStateMachine::InitWrapper, this);
+    static_pointer_cast<FairMQFSM>(fFsm)->fInitTaskWrapperHandler = bind(&FairMQStateMachine::InitTaskWrapper, this);
+    static_pointer_cast<FairMQFSM>(fFsm)->fRunWrapperHandler = bind(&FairMQStateMachine::RunWrapper, this);
+    static_pointer_cast<FairMQFSM>(fFsm)->fPauseWrapperHandler = bind(&FairMQStateMachine::PauseWrapper, this);
+    static_pointer_cast<FairMQFSM>(fFsm)->fResetWrapperHandler = bind(&FairMQStateMachine::ResetWrapper, this);
+    static_pointer_cast<FairMQFSM>(fFsm)->fResetTaskWrapperHandler = bind(&FairMQStateMachine::ResetTaskWrapper, this);
+    static_pointer_cast<FairMQFSM>(fFsm)->fExitHandler = bind(&FairMQStateMachine::Exit, this);
    static_pointer_cast<FairMQFSM>(fFsm)->fUnblockHandler = bind(&FairMQStateMachine::Unblock, this);

    static_pointer_cast<FairMQFSM>(fFsm)->start();
@@ -444,79 +552,79 @@ bool FairMQStateMachine::ChangeState(int event)
            case INIT_DEVICE:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(INIT_DEVICE_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(INIT_DEVICE_E());
                return true;
            }
            case internal_DEVICE_READY:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(internal_DEVICE_READY_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(internal_DEVICE_READY_E());
                return true;
            }
            case INIT_TASK:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(INIT_TASK_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(INIT_TASK_E());
                return true;
            }
            case internal_READY:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(internal_READY_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(internal_READY_E());
                return true;
            }
            case RUN:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(RUN_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(RUN_E());
                return true;
            }
            case PAUSE:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(PAUSE_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(PAUSE_E());
                return true;
            }
            case STOP:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(STOP_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(STOP_E());
                return true;
            }
            case RESET_DEVICE:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(RESET_DEVICE_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(RESET_DEVICE_E());
                return true;
            }
            case RESET_TASK:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(RESET_TASK_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(RESET_TASK_E());
                return true;
            }
            case internal_IDLE:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(internal_IDLE_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(internal_IDLE_E());
                return true;
            }
            case END:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(END_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(END_E());
                return true;
            }
            case ERROR_FOUND:
            {
                lock_guard<mutex> lock(fChangeStateMutex);
-                static_pointer_cast<FairMQFSM>(fFsm)->process_event(ERROR_FOUND_FSM_EVENT());
+                static_pointer_cast<FairMQFSM>(fFsm)->process_event(ERROR_FOUND_E());
                return true;
            }
            default:
            {
                LOG(error) << "Requested state transition with an unsupported event: " << event << endl
-                           << "Supported are: INIT_DEVICE, INIT_TASK, RUN, PAUSE, STOP, RESET_TASK, RESET_DEVICE, END, ERROR_FOUND";
+                            << "Supported are: INIT_DEVICE, INIT_TASK, RUN, PAUSE, STOP, RESET_TASK, RESET_DEVICE, END, ERROR_FOUND";
                return false;
            }
        }
@@ -630,11 +738,7 @@ void FairMQStateMachine::CallStateChangeCallbacks(const State state) const

 string FairMQStateMachine::GetCurrentStateName() const
 {
-    return GetStateName(static_pointer_cast<FairMQFSM>(fFsm)->fState);
-}
-string FairMQStateMachine::GetStateName(const State state)
-{
-    return stateNames.at(state);
+    return static_pointer_cast<FairMQFSM>(fFsm)->GetStateName(static_pointer_cast<FairMQFSM>(fFsm)->fState);
 }
 int FairMQStateMachine::GetCurrentState() const
 {
@@ -649,12 +753,23 @@ bool FairMQStateMachine::CheckCurrentState(string state) const
    return state == GetCurrentStateName();
 }

-void FairMQStateMachine::ProcessWork()
+bool FairMQStateMachine::Terminated()
 {
-    static_pointer_cast<FairMQFSM>(fFsm)->ProcessWork();
+    return static_pointer_cast<FairMQFSM>(fFsm)->fTerminationRequested;
 }

 int FairMQStateMachine::GetEventNumber(const string& event)
 {
-    return eventNumbers.at(event);
+    if (event == "INIT_DEVICE") return INIT_DEVICE;
+    if (event == "INIT_TASK") return INIT_TASK;
+    if (event == "RUN") return RUN;
+    if (event == "PAUSE") return PAUSE;
+    if (event == "STOP") return STOP;
+    if (event == "RESET_DEVICE") return RESET_DEVICE;
+    if (event == "RESET_TASK") return RESET_TASK;
+    if (event == "END") return END;
+    if (event == "ERROR_FOUND") return ERROR_FOUND;
+    LOG(error) << "Requested number for non-existent event... " << event << endl
+               << "Supported are: INIT_DEVICE, INIT_TASK, RUN, PAUSE, STOP, RESET_DEVICE, RESET_TASK, END, ERROR_FOUND";
+    return -1;
 }
--- a/fairmq/FairMQStateMachine.h
+++ b/fairmq/FairMQStateMachine.h
@@ -79,10 +79,10 @@ class FairMQStateMachine
    void CallStateChangeCallbacks(const State state) const;

    std::string GetCurrentStateName() const;
-    static std::string GetStateName(const State);
    int GetCurrentState() const;
    bool CheckCurrentState(int state) const;
    bool CheckCurrentState(std::string state) const;
+    bool Terminated();

    // actions to be overwritten by derived classes
    virtual void InitWrapper() {}
@@ -94,10 +94,8 @@ class FairMQStateMachine
    virtual void Exit() {}
    virtual void Unblock() {}

-    void ProcessWork();
-
  private:
-    static int GetEventNumber(const std::string& event);
+    int GetEventNumber(const std::string& event);

    std::mutex fChangeStateMutex;

--- a/fairmq/Plugin.h
+++ b/fairmq/Plugin.h
@@ -116,9 +116,9 @@ class Plugin
 } /* namespace fair */

 #define REGISTER_FAIRMQ_PLUGIN(KLASS, NAME, VERSION, MAINTAINER, HOMEPAGE, PROGOPTIONS) \
-static auto Make_##NAME##_Plugin(fair::mq::PluginServices* pluginServices) -> std::unique_ptr<fair::mq::Plugin> \
+static auto Make_##NAME##_Plugin(fair::mq::PluginServices* pluginServices) -> std::shared_ptr<fair::mq::Plugin> \
 { \
-    return fair::mq::tools::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
+    return std::make_shared<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
 } \
 BOOST_DLL_ALIAS(Make_##NAME##_Plugin, make_##NAME##_plugin) \
 BOOST_DLL_ALIAS(PROGOPTIONS, get_##NAME##_plugin_progoptions)
--- a/fairmq/PluginManager.cxx
+++ b/fairmq/PluginManager.cxx
@@ -31,53 +31,11 @@ const std::string fair::mq::PluginManager::fgkLibPrefix = "FairMQPlugin_";
 fair::mq::PluginManager::PluginManager()
    : fSearchPaths{{"."}}
    , fPluginFactories()
-    , fPluginServices()
    , fPlugins()
    , fPluginOrder()
    , fPluginProgOptions()
-{
-}
-
-fair::mq::PluginManager::PluginManager(const vector<string> args)
-    : fSearchPaths{{"."}}
-    , fPluginFactories()
    , fPluginServices()
-    , fPlugins()
-    , fPluginOrder()
-    , fPluginProgOptions()
 {
-    // Parse command line options
-    auto options = ProgramOptions();
-    auto vm = po::variables_map{};
-    try
-    {
-        auto parsed = po::command_line_parser(args).options(options).allow_unregistered().run();
-        po::store(parsed, vm);
-        po::notify(vm);
-    } catch (const po::error& e)
-    {
-        throw ProgramOptionsParseError{ToString("Error occured while parsing the 'Plugin Manager' program options: ", e.what())};
-    }
-
-    // Process plugin search paths
-    auto append = vector<fs::path>{};
-    auto prepend = vector<fs::path>{};
-    auto searchPaths = vector<fs::path>{};
-    if (vm.count("plugin-search-path"))
-    {
-        for (const auto& path : vm["plugin-search-path"].as<vector<string>>())
-        {
-            if      (path.substr(0, 1) == "<") { prepend.emplace_back(path.substr(1)); }
-            else if (path.substr(0, 1) == ">") { append.emplace_back(path.substr(1)); }
-            else                               { searchPaths.emplace_back(path); }
-        }
-    }
-
-    // Set supplied options
-    SetSearchPaths(searchPaths);
-    for(const auto& path : prepend) { PrependSearchPath(path); }
-    for(const auto& path : append)  { AppendSearchPath(path); }
-    if (vm.count("plugin")) { LoadPlugins(vm["plugin"].as<vector<string>>()); }
 }

 auto fair::mq::PluginManager::ValidateSearchPath(const fs::path& path) -> void
@@ -123,6 +81,46 @@ auto fair::mq::PluginManager::ProgramOptions() -> po::options_description
    return plugin_options;
 }

+auto fair::mq::PluginManager::MakeFromCommandLineOptions(const vector<string> args) -> shared_ptr<PluginManager>
+{
+    // Parse command line options
+    auto options = ProgramOptions();
+    auto vm = po::variables_map{};
+    try
+    {
+        auto parsed = po::command_line_parser(args).options(options).allow_unregistered().run();
+        po::store(parsed, vm);
+        po::notify(vm);
+    } catch (const po::error& e)
+    {
+        throw ProgramOptionsParseError{ToString("Error occured while parsing the 'Plugin Manager' program options: ", e.what())};
+    }
+
+    // Process plugin search paths
+    auto append = vector<fs::path>{};
+    auto prepend = vector<fs::path>{};
+    auto searchPaths = vector<fs::path>{};
+    if (vm.count("plugin-search-path"))
+    {
+        for (const auto& path : vm["plugin-search-path"].as<vector<string>>())
+        {
+            if      (path.substr(0, 1) == "<") { prepend.emplace_back(path.substr(1)); }
+            else if (path.substr(0, 1) == ">") { append.emplace_back(path.substr(1)); }
+            else                               { searchPaths.emplace_back(path); }
+        }
+    }
+
+    // Create PluginManager with supplied options
+    auto mgr = make_shared<PluginManager>();
+    mgr->SetSearchPaths(searchPaths);
+    for(const auto& path : prepend) { mgr->PrependSearchPath(path); }
+    for(const auto& path : append)  { mgr->AppendSearchPath(path); }
+    if (vm.count("plugin")) { mgr->LoadPlugins(vm["plugin"].as<vector<string>>()); }
+
+    // Return the plugin manager and command line options, that have not been recognized.
+    return mgr;
+}
+
 auto fair::mq::PluginManager::LoadPlugin(const string& pluginName) -> void
 {
    if (pluginName.substr(0,2) == "p:")
--- a/fairmq/PluginManager.h
+++ b/fairmq/PluginManager.h
@@ -47,15 +47,9 @@ namespace mq
 class PluginManager
 {
  public:
-    using PluginFactory = std::unique_ptr<fair::mq::Plugin>(PluginServices&);
+    using PluginFactory = std::shared_ptr<fair::mq::Plugin>(PluginServices&);

    PluginManager();
-    PluginManager(const std::vector<std::string> args);
-
-    ~PluginManager()
-    {
-        LOG(debug) << "Shutting down Plugin Manager";
-    }

    auto SetSearchPaths(const std::vector<boost::filesystem::path>&) -> void;
    auto AppendSearchPath(const boost::filesystem::path&) -> void;
@@ -70,6 +64,7 @@ class PluginManager
    struct PluginInstantiationError : std::runtime_error { using std::runtime_error::runtime_error; };

    static auto ProgramOptions() -> boost::program_options::options_description;
+    static auto MakeFromCommandLineOptions(const std::vector<std::string>) -> std::shared_ptr<PluginManager>;
    struct ProgramOptionsParseError : std::runtime_error { using std::runtime_error::runtime_error; };

    static auto LibPrefix() -> const std::string& { return fgkLibPrefix; }
@@ -116,10 +111,10 @@ class PluginManager
    static const std::string fgkLibPrefix;
    std::vector<boost::filesystem::path> fSearchPaths;
    std::map<std::string, std::function<PluginFactory>> fPluginFactories;
-    std::unique_ptr<PluginServices> fPluginServices;
-    std::map<std::string, std::unique_ptr<Plugin>> fPlugins;
+    std::map<std::string, std::shared_ptr<Plugin>> fPlugins;
    std::vector<std::string> fPluginOrder;
    std::map<std::string, boost::program_options::options_description> fPluginProgOptions;
+    std::unique_ptr<PluginServices> fPluginServices;
 }; /* class PluginManager */

 } /* namespace mq */
--- a/fairmq/PluginServices.cxx
+++ b/fairmq/PluginServices.cxx
@@ -98,7 +98,7 @@ auto PluginServices::ChangeDeviceState(const std::string& controller, const Devi

    if (fDeviceController == controller)
    {
-        fDevice.ChangeState(fkDeviceStateTransitionMap.at(next));
+        fDevice->ChangeState(fkDeviceStateTransitionMap.at(next));
    }
    else
    {
--- a/fairmq/PluginServices.h
+++ b/fairmq/PluginServices.h
@@ -38,20 +38,15 @@ class PluginServices
 {
  public:
    PluginServices() = delete;
-    PluginServices(FairMQProgOptions& config, FairMQDevice& device)
-        : fConfig(config)
-        , fDevice(device)
+    PluginServices(FairMQProgOptions* config, std::shared_ptr<FairMQDevice> device)
+        : fConfig{config}
+        , fDevice{device}
        , fDeviceController()
        , fDeviceControllerMutex()
        , fReleaseDeviceControlCondition()
    {
    }

-    ~PluginServices()
-    {
-        LOG(debug) << "Shutting down Plugin Services";
-    }
-
    PluginServices(const PluginServices&) = delete;
    PluginServices operator=(const PluginServices&) = delete;

@@ -114,7 +109,7 @@ class PluginServices
    friend auto operator<<(std::ostream& os, const DeviceStateTransition& transition) -> std::ostream& { return os << ToStr(transition); }

    /// @return current device state
-    auto GetCurrentDeviceState() const -> DeviceState { return fkDeviceStateMap.at(static_cast<FairMQDevice::State>(fDevice.GetCurrentState())); }
+    auto GetCurrentDeviceState() const -> DeviceState { return fkDeviceStateMap.at(static_cast<FairMQDevice::State>(fDevice->GetCurrentState())); }

    /// @brief Become device controller
    /// @param controller id
@@ -160,19 +155,19 @@ class PluginServices
    /// the state is running in.
    auto SubscribeToDeviceStateChange(const std::string& subscriber, std::function<void(DeviceState /*newState*/)> callback) -> void
    {
-        fDevice.SubscribeToStateChange(subscriber, [&,callback](FairMQDevice::State newState){
+        fDevice->SubscribeToStateChange(subscriber, [&,callback](FairMQDevice::State newState){
            callback(fkDeviceStateMap.at(newState));
        });
    }

    /// @brief Unsubscribe from device state changes
    /// @param subscriber id
-    auto UnsubscribeFromDeviceStateChange(const std::string& subscriber) -> void { fDevice.UnsubscribeFromStateChange(subscriber); }
+    auto UnsubscribeFromDeviceStateChange(const std::string& subscriber) -> void { fDevice->UnsubscribeFromStateChange(subscriber); }

    // Config API
    struct PropertyNotFoundError : std::runtime_error { using std::runtime_error::runtime_error; };

-    auto PropertyExists(const std::string& key) const -> bool { return fConfig.Count(key) > 0; }
+    auto PropertyExists(const std::string& key) const -> bool { return fConfig->Count(key) > 0; }

    /// @brief Set config property
    /// @param key
@@ -187,7 +182,7 @@ class PluginServices
        auto currentState = GetCurrentDeviceState();
        if (currentState == DeviceState::InitializingDevice)
        {
-            fConfig.SetValue(key, val);
+            fConfig->SetValue(key, val);
        }
        else
        {
@@ -205,7 +200,7 @@ class PluginServices
    template<typename T>
    auto GetProperty(const std::string& key) const -> T {
        if (PropertyExists(key)) {
-            return fConfig.GetValue<T>(key);
+            return fConfig->GetValue<T>(key);
        }
        throw PropertyNotFoundError(fair::mq::tools::ToString("Config has no key: ", key));
    }
@@ -217,16 +212,16 @@ class PluginServices
    /// If a type is not supported, the user can provide support by overloading the ostream operator for this type
    auto GetPropertyAsString(const std::string& key) const -> std::string {
        if (PropertyExists(key)) {
-            return fConfig.GetStringValue(key);
+            return fConfig->GetStringValue(key);
        }
        throw PropertyNotFoundError(fair::mq::tools::ToString("Config has no key: ", key));
    }

-    auto GetChannelInfo() const -> std::unordered_map<std::string, int> { return fConfig.GetChannelInfo(); }
+    auto GetChannelInfo() const -> std::unordered_map<std::string, int> { return fConfig->GetChannelInfo(); }

    /// @brief Discover the list of property keys
    /// @return list of property keys
-    auto GetPropertyKeys() const -> std::vector<std::string> { return fConfig.GetPropertyKeys(); }
+    auto GetPropertyKeys() const -> std::vector<std::string> { return fConfig->GetPropertyKeys(); }

    /// @brief Subscribe to property updates of type T
    /// @param subscriber
@@ -236,13 +231,13 @@ class PluginServices
    template<typename T>
    auto SubscribeToPropertyChange(const std::string& subscriber, std::function<void(const std::string& key, T)> callback) const -> void
    {
-        fConfig.Subscribe<T>(subscriber, callback);
+        fConfig->Subscribe<T>(subscriber, callback);
    }

    /// @brief Unsubscribe from property updates of type T
    /// @param subscriber
    template<typename T>
-    auto UnsubscribeFromPropertyChange(const std::string& subscriber) -> void { fConfig.Unsubscribe<T>(subscriber); }
+    auto UnsubscribeFromPropertyChange(const std::string& subscriber) -> void { fConfig->Unsubscribe<T>(subscriber); }

    /// @brief Subscribe to property updates
    /// @param subscriber
@@ -251,12 +246,12 @@ class PluginServices
    /// Subscribe to property changes with a callback to monitor property changes in an event based fashion. Will convert the property to string.
    auto SubscribeToPropertyChangeAsString(const std::string& subscriber, std::function<void(const std::string& key, std::string)> callback) const -> void
    {
-        fConfig.SubscribeAsString(subscriber, callback);
+        fConfig->SubscribeAsString(subscriber, callback);
    }

    /// @brief Unsubscribe from property updates that convert to string
    /// @param subscriber
-    auto UnsubscribeFromPropertyChangeAsString(const std::string& subscriber) -> void { fConfig.UnsubscribeAsString(subscriber); }
+    auto UnsubscribeFromPropertyChangeAsString(const std::string& subscriber) -> void { fConfig->UnsubscribeAsString(subscriber); }

    auto CycleLogConsoleSeverityUp() -> void { Logger::CycleConsoleSeverityUp(); }
    auto CycleLogConsoleSeverityDown() -> void { Logger::CycleConsoleSeverityDown(); }
@@ -271,8 +266,8 @@ class PluginServices
    static const std::unordered_map<DeviceStateTransition, FairMQDevice::Event, tools::HashEnum<DeviceStateTransition>> fkDeviceStateTransitionMap;

  private:
-    FairMQProgOptions& fConfig;
-    FairMQDevice& fDevice;
+    FairMQProgOptions* fConfig; // TODO make it a shared pointer, once old AliceO2 code is cleaned up
+    std::shared_ptr<FairMQDevice> fDevice;
    boost::optional<std::string> fDeviceController;
    mutable std::mutex fDeviceControllerMutex;
    std::condition_variable fReleaseDeviceControlCondition;
--- a/fairmq/devices/FairMQBenchmarkSampler.h
+++ b/fairmq/devices/FairMQBenchmarkSampler.h
@@ -17,7 +17,6 @@

 #include <string>
 #include <thread>
-#include <atomic>

 #include "FairMQDevice.h"

@@ -39,7 +38,7 @@ class FairMQBenchmarkSampler : public FairMQDevice
  protected:
    bool fSameMessage;
    int fMsgSize;
-    std::atomic<int> fMsgCounter;
+    int fMsgCounter;
    int fMsgRate;
    uint64_t fNumIterations;
    uint64_t fMaxIterations;
--- a/fairmq/ofi/Message.cxx
+++ b/fairmq/ofi/Message.cxx
@@ -10,7 +10,6 @@
 #include <fairmq/Tools.h>
 #include <FairMQLogger.h>

-#include <cassert>
 #include <cstdlib>
 #include <zmq.h>

@@ -54,7 +53,7 @@ Message::Message(void* data, const size_t size, fairmq_free_fn* ffn, void* hint)
 {
 }

-Message::Message(FairMQUnmanagedRegionPtr& /*region*/, void* /*data*/, const size_t /*size*/, void* /*hint*/)
+Message::Message(FairMQUnmanagedRegionPtr& region, void* data, const size_t size, void* hint)
 {
    throw MessageError{"Not yet implemented."};
 }
@@ -92,7 +91,7 @@ auto Message::Rebuild(const size_t size) -> void
    fHint = nullptr;
 }

-auto Message::Rebuild(void* /*data*/, const size_t size, fairmq_free_fn* ffn, void* hint) -> void
+auto Message::Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint) -> void
 {
    if (fFreeFunction) {
      fFreeFunction(fData, fHint);
@@ -133,12 +132,12 @@ auto Message::SetUsedSize(const size_t size) -> bool
    }
 }

-auto Message::Copy(const fair::mq::Message& /*msg*/) -> void
+auto Message::Copy(const fair::mq::Message& msg) -> void
 {
    throw MessageError{"Not yet implemented."};
 }

-auto Message::Copy(const fair::mq::MessagePtr& /*msg*/) -> void
+auto Message::Copy(const fair::mq::MessagePtr& msg) -> void
 {
    throw MessageError{"Not yet implemented."};
 }
--- a/fairmq/plugins/Control.cxx
+++ b/fairmq/plugins/Control.cxx
@@ -17,11 +17,12 @@ using namespace std;

 namespace
 {
-    volatile sig_atomic_t gSignalStatus = 0;
+    // ugly global state, but std::signal gives us no other choice
+    std::function<void(int)> gSignalHandlerClosure;

    extern "C" auto signal_handler(int signal) -> void
    {
-        gSignalStatus = signal;
+        gSignalHandlerClosure(signal);
    }
 }

@@ -36,13 +37,10 @@ Control::Control(const string name, const Plugin::Version version, const string
    : Plugin(name, version, maintainer, homepage, pluginServices)
    , fControllerThread()
    , fSignalHandlerThread()
-    , fShutdownThread()
    , fEvents()
    , fEventsMutex()
-    , fShutdownMutex()
    , fNewEvent()
-    , fDeviceTerminationRequested(false)
-    , fHasShutdown(false)
+    , fDeviceTerminationRequested{false}
 {
    try
    {
@@ -75,7 +73,7 @@ Control::Control(const string name, const Plugin::Version version, const string
    LOG(debug) << "catch-signals: " << GetProperty<int>("catch-signals");
    if (GetProperty<int>("catch-signals") > 0)
    {
-        fSignalHandlerThread = thread(&Control::SignalHandler, this);
+        gSignalHandlerClosure = bind(&Control::SignalHandler, this, placeholders::_1);
        signal(SIGINT, signal_handler);
        signal(SIGTERM, signal_handler);
    }
@@ -229,7 +227,7 @@ auto Control::WaitForNextState() -> DeviceState
    unique_lock<mutex> lock{fEventsMutex};
    while (fEvents.empty())
    {
-        fNewEvent.wait(lock);
+        fNewEvent.wait_for(lock, chrono::milliseconds(50));
    }

    auto result = fEvents.front();
@@ -265,92 +263,69 @@ auto Control::StaticMode() -> void
    }
 }

-auto Control::SignalHandler() -> void
+auto Control::SignalHandler(int signal) -> void
 {
-    while (true)
+    if (!fDeviceTerminationRequested)
    {
-        if (gSignalStatus != 0 && !fHasShutdown)
-        {
-            LOG(info) << "Received device shutdown request (signal " << gSignalStatus << ").";
-            LOG(info) << "Waiting for graceful device shutdown. Hit Ctrl-C again to abort immediately.";
+        fDeviceTerminationRequested = true;

-            if (!fDeviceTerminationRequested)
-            {
-                fDeviceTerminationRequested = true;
-                gSignalStatus = 0;
-                fShutdownThread = thread(&Control::HandleShutdownSignal, this);
-            }
-            else
-            {
-                LOG(warn) << "Received 2nd device shutdown request (signal " << gSignalStatus << ").";
-                LOG(warn) << "Aborting immediately!";
-                abort();
-            }
-        }
-        else if (fHasShutdown)
-        {
-            break;
-        }
+        StealDeviceControl();

-        this_thread::sleep_for(chrono::milliseconds(100));
+        LOG(info) << "Received device shutdown request (signal " << signal << ").";
+        LOG(info) << "Waiting for graceful device shutdown. Hit Ctrl-C again to abort immediately.";
+
+        UnsubscribeFromDeviceStateChange(); // In case, static or interactive mode have subscribed already
+        SubscribeToDeviceStateChange([&](DeviceState newState)
+        {
+            {
+                lock_guard<mutex> lock{fEventsMutex};
+                fEvents.push(newState);
+            }
+            fNewEvent.notify_one();
+        });
+
+        fSignalHandlerThread = thread(&Control::RunShutdownSequence, this);
    }
-}
-
-auto Control::HandleShutdownSignal() -> void
-{
-    StealDeviceControl();
-
-    UnsubscribeFromDeviceStateChange(); // In case, static or interactive mode have subscribed already
-    SubscribeToDeviceStateChange([&](DeviceState newState)
+    else
    {
-        {
-            lock_guard<mutex> lock{fEventsMutex};
-            fEvents.push(newState);
-        }
-        fNewEvent.notify_one();
-    });
-
-    RunShutdownSequence();
+        LOG(warn) << "Received 2nd device shutdown request (signal " << signal << ").";
+        LOG(warn) << "Aborting immediately !";
+        abort();
+    }
 }

 auto Control::RunShutdownSequence() -> void
 {
-    lock_guard<mutex> lock(fShutdownMutex);
-    if (!fHasShutdown)
+    auto nextState = GetCurrentDeviceState();
+    EmptyEventQueue();
+    while (nextState != DeviceState::Exiting)
    {
-        auto nextState = GetCurrentDeviceState();
-        EmptyEventQueue();
-        while (nextState != DeviceState::Exiting)
+        switch (nextState)
        {
-            switch (nextState)
-            {
-                case DeviceState::Idle:
-                    ChangeDeviceState(DeviceStateTransition::End);
-                    break;
-                case DeviceState::DeviceReady:
-                    ChangeDeviceState(DeviceStateTransition::ResetDevice);
-                    break;
-                case DeviceState::Ready:
-                    ChangeDeviceState(DeviceStateTransition::ResetTask);
-                    break;
-                case DeviceState::Running:
-                    ChangeDeviceState(DeviceStateTransition::Stop);
-                    break;
-                case DeviceState::Paused:
-                    ChangeDeviceState(DeviceStateTransition::Resume);
-                    break;
-                default:
-                    // ignore other states
-                    break;
-            }
-
-            nextState = WaitForNextState();
+            case DeviceState::Idle:
+                ChangeDeviceState(DeviceStateTransition::End);
+                break;
+            case DeviceState::DeviceReady:
+                ChangeDeviceState(DeviceStateTransition::ResetDevice);
+                break;
+            case DeviceState::Ready:
+                ChangeDeviceState(DeviceStateTransition::ResetTask);
+                break;
+            case DeviceState::Running:
+                ChangeDeviceState(DeviceStateTransition::Stop);
+                break;
+            case DeviceState::Paused:
+                ChangeDeviceState(DeviceStateTransition::Resume);
+                break;
+            default:
+                break;
        }

-        fHasShutdown = true;
-        UnsubscribeFromDeviceStateChange();
-        ReleaseDeviceControl();
+        nextState = WaitForNextState();
    }
+
+    UnsubscribeFromDeviceStateChange();
+    ReleaseDeviceControl();
 }

 auto Control::RunStartupSequence() -> void
@@ -382,7 +357,6 @@ Control::~Control()
 {
    if (fControllerThread.joinable()) fControllerThread.join();
    if (fSignalHandlerThread.joinable()) fSignalHandlerThread.join();
-    if (fShutdownThread.joinable()) fShutdownThread.join();
 }

 } /* namespace plugins */
--- a/fairmq/plugins/Control.h
+++ b/fairmq/plugins/Control.h
@@ -37,21 +37,17 @@ class Control : public Plugin
    auto PrintInteractiveHelp() -> void;
    auto StaticMode() -> void;
    auto WaitForNextState() -> DeviceState;
-    auto SignalHandler() -> void;
-    auto HandleShutdownSignal() -> void;
+    auto SignalHandler(int signal) -> void;
    auto RunShutdownSequence() -> void;
    auto RunStartupSequence() -> void;
    auto EmptyEventQueue() -> void;

    std::thread fControllerThread;
    std::thread fSignalHandlerThread;
-    std::thread fShutdownThread;
    std::queue<DeviceState> fEvents;
    std::mutex fEventsMutex;
-    std::mutex fShutdownMutex;
    std::condition_variable fNewEvent;
    std::atomic<bool> fDeviceTerminationRequested;
-    std::atomic<bool> fHasShutdown;
 }; /* class Control */

 auto ControlPluginProgramOptions() -> Plugin::ProgOptions;
--- a/fairmq/runFairMQDevice.h
+++ b/fairmq/runFairMQDevice.h
@@ -46,7 +46,7 @@ int main(int argc, char* argv[])
        // });

        runner.AddHook<InstantiateDevice>([](DeviceRunner& r){
-            r.fDevice = std::unique_ptr<FairMQDevice>{getDevice(r.fConfig)};
+            r.fDevice = std::shared_ptr<FairMQDevice>{getDevice(r.fConfig)};
        });

        return runner.Run();
--- a/fairmq/shmem/FairMQMessageSHM.cxx
+++ b/fairmq/shmem/FairMQMessageSHM.cxx
@@ -19,8 +19,8 @@
 using namespace std;
 using namespace fair::mq::shmem;

-namespace bipc = ::boost::interprocess;
-namespace bpt = ::boost::posix_time;
+namespace bipc = boost::interprocess;
+namespace bpt = boost::posix_time;

 atomic<bool> FairMQMessageSHM::fInterrupted(false);
 fair::mq::Transport FairMQMessageSHM::fTransportType = fair::mq::Transport::SHM;
--- a/fairmq/shmem/FairMQSocketSHM.cxx
+++ b/fairmq/shmem/FairMQSocketSHM.cxx
@@ -351,7 +351,7 @@ int64_t FairMQSocketSHM::ReceiveImpl(vector<FairMQMessagePtr>& msgVec, const int

            msgVec.reserve(lNumMessages);

-            for (size_t m = 0; m < lNumMessages; m++)
+            for (auto m = 0; m < lNumMessages; m++)
            {
                MetaHeader lMetaHeader;
                memcpy(&lMetaHeader, &lHdrVec[m], sizeof(MetaHeader));
--- a/fairmq/shmem/FairMQTransportFactorySHM.cxx
+++ b/fairmq/shmem/FairMQTransportFactorySHM.cxx
@@ -28,9 +28,9 @@
 using namespace std;
 using namespace fair::mq::shmem;

-namespace bfs = ::boost::filesystem;
-namespace bpt = ::boost::posix_time;
-namespace bipc = ::boost::interprocess;
+namespace bfs = boost::filesystem;
+namespace bpt = boost::posix_time;
+namespace bipc = boost::interprocess;

 fair::mq::Transport FairMQTransportFactorySHM::fTransportType = fair::mq::Transport::SHM;

--- a/fairmq/shmem/FairMQUnmanagedRegionSHM.cxx
+++ b/fairmq/shmem/FairMQUnmanagedRegionSHM.cxx
@@ -13,7 +13,7 @@
 using namespace std;
 using namespace fair::mq::shmem;

-namespace bipc = ::boost::interprocess;
+namespace bipc = boost::interprocess;

 FairMQUnmanagedRegionSHM::FairMQUnmanagedRegionSHM(Manager& manager, const size_t size, FairMQRegionCallback callback)
    : fManager(manager)
--- a/fairmq/shmem/Manager.cxx
+++ b/fairmq/shmem/Manager.cxx
@@ -9,9 +9,6 @@
 #include <fairmq/shmem/Manager.h>
 #include <fairmq/shmem/Common.h>

-using namespace std;
-namespace bipc = ::boost::interprocess;
-
 namespace fair
 {
 namespace mq
@@ -19,6 +16,9 @@ namespace mq
 namespace shmem
 {

+using namespace std;
+namespace bipc = boost::interprocess;
+
 std::unordered_map<uint64_t, Region> Manager::fRegions;

 Manager::Manager(const string& name, size_t size)
--- a/fairmq/shmem/Monitor.cxx
+++ b/fairmq/shmem/Monitor.cxx
@@ -26,8 +26,8 @@
 #include <poll.h>

 using namespace std;
-namespace bipc = ::boost::interprocess;
-namespace bpt = ::boost::posix_time;
+namespace bipc = boost::interprocess;
+namespace bpt = boost::posix_time;

 using CharAllocator   = bipc::allocator<char, bipc::managed_shared_memory::segment_manager>;
 using String          = bipc::basic_string<char, char_traits<char>, CharAllocator>;
--- a/fairmq/shmem/Region.cxx
+++ b/fairmq/shmem/Region.cxx
@@ -12,11 +12,6 @@

 #include <boost/date_time/posix_time/posix_time.hpp>

-using namespace std;
-
-namespace bipc = ::boost::interprocess;
-namespace bpt = ::boost::posix_time;
-
 namespace fair
 {
 namespace mq
@@ -24,6 +19,11 @@ namespace mq
 namespace shmem
 {

+using namespace std;
+
+namespace bipc = boost::interprocess;
+namespace bpt = boost::posix_time;
+
 Region::Region(Manager& manager, uint64_t id, uint64_t size, bool remote, FairMQRegionCallback callback)
    : fManager(manager)
    , fRemote(remote)
--- a/test/device/_multiple_devices.cxx
+++ b/test/device/_multiple_devices.cxx
@@ -12,7 +12,6 @@
 #include <gtest/gtest.h>

 #include <string>
-#include <thread>
 #include <future> // std::async, std::future

 namespace
@@ -20,24 +19,6 @@ namespace

 using namespace std;

-void control(FairMQDevice& device)
-{
-    device.ChangeState("INIT_DEVICE");
-    device.WaitForEndOfState("INIT_DEVICE");
-    device.ChangeState("INIT_TASK");
-    device.WaitForEndOfState("INIT_TASK");
-
-    device.ChangeState("RUN");
-    device.WaitForEndOfState("RUN");
-
-    device.ChangeState("RESET_TASK");
-    device.WaitForEndOfState("RESET_TASK");
-    device.ChangeState("RESET_DEVICE");
-    device.WaitForEndOfState("RESET_DEVICE");
-
-    device.ChangeState("END");
-}
-
 class MultipleDevices : public ::testing::Test {
  public:
    MultipleDevices()
@@ -53,14 +34,20 @@ class MultipleDevices : public ::testing::Test {
        channel.UpdateRateLogging(0);
        sender.fChannels["data"].push_back(channel);

-        thread t(control, std::ref(sender));
+        sender.ChangeState("INIT_DEVICE");
+        sender.WaitForEndOfState("INIT_DEVICE");
+        sender.ChangeState("INIT_TASK");
+        sender.WaitForEndOfState("INIT_TASK");

-        sender.RunStateMachine();
+        sender.ChangeState("RUN");
+        sender.WaitForEndOfState("RUN");

-        if (t.joinable())
-        {
-            t.join();
-        }
+        sender.ChangeState("RESET_TASK");
+        sender.WaitForEndOfState("RESET_TASK");
+        sender.ChangeState("RESET_DEVICE");
+        sender.WaitForEndOfState("RESET_DEVICE");
+
+        sender.ChangeState("END");

        return true;
    }
@@ -75,14 +62,20 @@ class MultipleDevices : public ::testing::Test {
        channel.UpdateRateLogging(0);
        receiver.fChannels["data"].push_back(channel);

-        thread t(control, std::ref(receiver));
+        receiver.ChangeState("INIT_DEVICE");
+        receiver.WaitForEndOfState("INIT_DEVICE");
+        receiver.ChangeState("INIT_TASK");
+        receiver.WaitForEndOfState("INIT_TASK");

-        receiver.RunStateMachine();
+        receiver.ChangeState("RUN");
+        receiver.WaitForEndOfState("RUN");

-        if (t.joinable())
-        {
-            t.join();
-        }
+        receiver.ChangeState("RESET_TASK");
+        receiver.WaitForEndOfState("RESET_TASK");
+        receiver.ChangeState("RESET_DEVICE");
+        receiver.WaitForEndOfState("RESET_DEVICE");
+
+        receiver.ChangeState("END");

        return true;
    }
--- a/test/plugin_services/Fixture.h
+++ b/test/plugin_services/Fixture.h
@@ -14,7 +14,6 @@
 #include <FairMQDevice.h>
 #include <options/FairMQProgOptions.h>
 #include <memory>
-#include <thread>

 namespace fair
 {
@@ -23,41 +22,35 @@ namespace mq
 namespace test
 {

-inline auto control(FairMQDevice& device) -> void
+inline auto control(std::shared_ptr<FairMQDevice> device) -> void
 {
    for (const auto event : {
        FairMQDevice::INIT_DEVICE,
        FairMQDevice::RESET_DEVICE,
        FairMQDevice::END,
    }) {
-        device.ChangeState(event);
-        if (event != FairMQDevice::END) device.WaitForEndOfState(event);
+        device->ChangeState(event);
+        if (event != FairMQDevice::END) device->WaitForEndOfState(event);
    }
 }

 struct PluginServices : ::testing::Test {
    PluginServices()
-        : mConfig()
-        , mDevice()
-        , mServices(mConfig, mDevice)
-        , fRunStateMachineThread()
+    : mConfig()
+    , mDevice{std::make_shared<FairMQDevice>()}
+    , mServices{&mConfig, mDevice}
    {
-        fRunStateMachineThread = std::thread(&FairMQDevice::RunStateMachine, &mDevice);
-        mDevice.SetTransport("zeromq");
+        mDevice->SetTransport("zeromq");
    }

    ~PluginServices()
    {
-        if (mDevice.GetCurrentState() == FairMQDevice::IDLE) control(mDevice);
-        if (fRunStateMachineThread.joinable()) {
-            fRunStateMachineThread.join();
-        }
+        if(mDevice->GetCurrentState() == FairMQDevice::IDLE) control(mDevice);
    }

    FairMQProgOptions mConfig;
-    FairMQDevice mDevice;
+    std::shared_ptr<FairMQDevice> mDevice;
    fair::mq::PluginServices mServices;
-    std::thread fRunStateMachineThread;
 };

 } /* namespace test */
--- a/test/plugin_services/_control.cxx
+++ b/test/plugin_services/_control.cxx
@@ -39,9 +39,9 @@ TEST_F(PluginServices, OnlySingleController)
    EXPECT_EQ(mServices.GetDeviceController(), string{"foo"});

    // park device
-    mDevice.WaitForEndOfState(FairMQDevice::DEVICE_READY);
+    mDevice->WaitForEndOfState(FairMQDevice::DEVICE_READY);
    mServices.ChangeDeviceState("foo", DeviceStateTransition::ResetDevice);
-    mDevice.WaitForEndOfState(FairMQDevice::RESET_DEVICE);
+    mDevice->WaitForEndOfState(FairMQDevice::RESET_DEVICE);
    mServices.ChangeDeviceState("foo", DeviceStateTransition::End);
 }

@@ -72,7 +72,7 @@ TEST_F(PluginServices, Control)
    ASSERT_EQ(mServices.GetCurrentDeviceState(), DeviceState::DeviceReady);

    mServices.ChangeDeviceState("foo", DeviceStateTransition::ResetDevice);
-    mDevice.WaitForEndOfState(FairMQDevice::RESET_DEVICE);
+    mDevice->WaitForEndOfState(FairMQDevice::RESET_DEVICE);
    mServices.ChangeDeviceState("foo", DeviceStateTransition::End);
 }

--- a/test/plugins/_plugin.cxx
+++ b/test/plugins/_plugin.cxx
@@ -16,7 +16,6 @@
 #include <sstream>
 #include <string>
 #include <vector>
-#include <thread>

 namespace
 {
@@ -24,50 +23,42 @@ namespace
 using namespace std;
 using namespace fair::mq;

-auto control(FairMQDevice& device) -> void
+auto control(shared_ptr<FairMQDevice> device) -> void
 {
-    device.SetTransport("zeromq");
+    device->SetTransport("zeromq");
    for (const auto event : {
        FairMQDevice::INIT_DEVICE,
        FairMQDevice::RESET_DEVICE,
        FairMQDevice::END,
    }) {
-        device.ChangeState(event);
-        if (event != FairMQDevice::END) device.WaitForEndOfState(event);
+        device->ChangeState(event);
+        if (event != FairMQDevice::END) device->WaitForEndOfState(event);
    }
 }

 TEST(Plugin, Operators)
 {
-    FairMQProgOptions config;
-    FairMQDevice device;
-    PluginServices services{config, device};
+    FairMQProgOptions config{};
+    auto device = make_shared<FairMQDevice>();
+    PluginServices services{&config, device};
    Plugin p1{"dds", {1, 0, 0}, "Foo Bar <foo.bar@test.net>", "https://git.test.net/dds.git", &services};
    Plugin p2{"dds", {1, 0, 0}, "Foo Bar <foo.bar@test.net>", "https://git.test.net/dds.git", &services};
    Plugin p3{"file", {1, 0, 0}, "Foo Bar <foo.bar@test.net>", "https://git.test.net/file.git", &services};
    EXPECT_EQ(p1, p2);
    EXPECT_NE(p1, p3);
-    thread t(control, std::ref(device));
-    device.RunStateMachine();
-    if (t.joinable()) {
-        t.join();
-    }
+    control(device);
 }

 TEST(Plugin, OstreamOperators)
 {
-    FairMQProgOptions config;
-    FairMQDevice device;
-    PluginServices services{config, device};
+    FairMQProgOptions config{};
+    auto device = make_shared<FairMQDevice>();
+    PluginServices services{&config, device};
    Plugin p1{"dds", {1, 0, 0}, "Foo Bar <foo.bar@test.net>", "https://git.test.net/dds.git", &services};
    stringstream ss;
    ss << p1;
    EXPECT_EQ(ss.str(), string{"'dds', version '1.0.0', maintainer 'Foo Bar <foo.bar@test.net>', homepage 'https://git.test.net/dds.git'"});
-    thread t(control, std::ref(device));
-    device.RunStateMachine();
-    if (t.joinable()) {
-        t.join();
-    }
+    control(device);
 }

 TEST(PluginVersion, Operators)
--- a/test/plugins/_plugin_manager.cxx
+++ b/test/plugins/_plugin_manager.cxx
@@ -15,7 +15,6 @@
 #include <fstream>
 #include <memory>
 #include <vector>
-#include <thread>

 namespace
 {
@@ -25,25 +24,25 @@ using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace std;

-auto control(FairMQDevice& device) -> void
+auto control(shared_ptr<FairMQDevice> device) -> void
 {
-    device.SetTransport("zeromq");
+    device->SetTransport("zeromq");
    for (const auto event : {
        FairMQDevice::INIT_DEVICE,
        FairMQDevice::RESET_DEVICE,
        FairMQDevice::END,
    }) {
-        device.ChangeState(event);
-        if (event != FairMQDevice::END) device.WaitForEndOfState(event);
+        device->ChangeState(event);
+        if (event != FairMQDevice::END) device->WaitForEndOfState(event);
    }
 }

 TEST(PluginManager, LoadPluginDynamic)
 {
-    FairMQProgOptions config;
-    FairMQDevice device;
-    PluginManager mgr;
-    mgr.EmplacePluginServices(config, device);
+    FairMQProgOptions config{};
+    auto mgr = PluginManager{};
+    auto device = make_shared<FairMQDevice>();
+    mgr.EmplacePluginServices(&config, device);

    mgr.PrependSearchPath("./test");

@@ -54,7 +53,7 @@ TEST(PluginManager, LoadPluginDynamic)

    // check order
    const auto expected = vector<string>{"test_dummy", "test_dummy2"};
-    auto actual = vector<string>();
+    auto actual = vector<string>{};
    mgr.ForEachPlugin([&](Plugin& plugin){ actual.push_back(plugin.GetName()); });
    ASSERT_TRUE(actual == expected);

@@ -63,31 +62,27 @@ TEST(PluginManager, LoadPluginDynamic)
    mgr.ForEachPluginProgOptions([&count](const options_description& /*d*/){ ++count; });
    ASSERT_EQ(count, 1);

-    thread t(control, std::ref(device));
-    device.RunStateMachine();
-    if (t.joinable()) {
-        t.join();
-    }
+    control(device);
 }

 TEST(PluginManager, LoadPluginStatic)
 {
-    FairMQDevice device;
-    PluginManager mgr;
-    device.SetTransport("zeromq");
+    auto mgr = PluginManager{};
+    auto device = make_shared<FairMQDevice>();
+    device->SetTransport("zeromq");

    ASSERT_NO_THROW(mgr.LoadPlugin("s:control"));

-    FairMQProgOptions config;
+    FairMQProgOptions config{};
    config.SetValue<string>("control", "static");
    config.SetValue("catch-signals", 0);
-    mgr.EmplacePluginServices(config, device);
+    mgr.EmplacePluginServices(&config, device);

    ASSERT_NO_THROW(mgr.InstantiatePlugins());

    // check order
    const auto expected = vector<string>{"control"};
-    auto actual = vector<string>();
+    auto actual = vector<string>{};
    mgr.ForEachPlugin([&](Plugin& plugin){ actual.push_back(plugin.GetName()); });
    ASSERT_TRUE(actual == expected);

@@ -96,22 +91,20 @@ TEST(PluginManager, LoadPluginStatic)
    mgr.ForEachPluginProgOptions([&count](const options_description&){ ++count; });
    ASSERT_EQ(count, 1);

-    device.RunStateMachine();
-
    mgr.WaitForPluginsToReleaseDeviceControl();
 }

 TEST(PluginManager, Factory)
 {
    const auto args = vector<string>{"-l", "debug", "--help", "-S", ">/lib", "</home/user/lib", "/usr/local/lib", "/usr/lib"};
-    PluginManager mgr(args);
+    auto mgr = PluginManager::MakeFromCommandLineOptions(args);
    const auto path1 = path{"/home/user/lib"};
    const auto path2 = path{"/usr/local/lib"};
    const auto path3 = path{"/usr/lib"};
    const auto path4 = path{"/lib"};
    const auto expected = vector<path>{path1, path2, path3, path4};
-    // ASSERT_TRUE(static_cast<bool>(mgr));
-    ASSERT_TRUE(mgr.SearchPaths() == expected);
+    ASSERT_TRUE(static_cast<bool>(mgr));
+    ASSERT_TRUE(mgr->SearchPaths() == expected);
 }

 TEST(PluginManager, SearchPathValidation)
@@ -119,7 +112,7 @@ TEST(PluginManager, SearchPathValidation)
    const auto path1 = path{"/tmp/test1"};
    const auto path2 = path{"/tmp/test2"};
    const auto path3 = path{"/tmp/test3"};
-    PluginManager mgr;
+    auto mgr = PluginManager{};

    mgr.SetSearchPaths({path1, path2});
    auto expected = vector<path>{path1, path2};
@@ -147,7 +140,7 @@ TEST(PluginManager, SearchPaths)
    fs.close();
    const auto empty_path = path{""};

-    PluginManager mgr;
+    auto mgr = PluginManager{};
    ASSERT_NO_THROW(mgr.AppendSearchPath(non_existing_dir));
    ASSERT_NO_THROW(mgr.AppendSearchPath(existing_dir));
    ASSERT_THROW(mgr.AppendSearchPath(existing_file), PluginManager::BadSearchPath);
--- a/test/plugins/_plugin_manager_prelink.cxx
+++ b/test/plugins/_plugin_manager_prelink.cxx
@@ -17,7 +17,7 @@ using namespace std;

 TEST(PluginManager, LoadPluginPrelinkedDynamic)
 {
-    PluginManager mgr;
+    auto mgr = PluginManager{};

    ASSERT_NO_THROW(mgr.LoadPlugin("p:test_dummy"));
    ASSERT_NO_THROW(mgr.LoadPlugin("p:test_dummy2"));