build(deps): bump extern/googletest from 7140cd4 to 973323e

Bumps [extern/googletest](https://github.com/google/googletest) from `7140cd4` to `973323e`.
- [Release notes](https://github.com/google/googletest/releases)
- [Commits](7140cd416c...973323ed64)

---
updated-dependencies:
- dependency-name: extern/googletest
  dependency-version: 973323ed64a05b128418e7eab67016db5ba049df
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

.clang-tidy

@@ -1,3 +1,3 @@
 ---
-Checks:            'cppcoreguidelines-*,misc-unused-alias-decls,misc-unused-parameters,modernize-pass-by-value,modernize-deprecated-headers,modernize-raw-string-literal,modernize-redundant-void-arg,modernize-use-bool-literals,modernize-use-default-member-init,modernize-use-emplace,modernize-use-equals-default,modernize-use-equals-delete,modernize-use-noexcept,modernize-use-nullptr,modernize-use-override,modernize-use-using,performance-faster-string-find,performance-for-range-copy,performance-unnecessary-copy-initialization,readability-avoid-const-params-in-decls,readability-braces-around-statements,readability-container-size-empty,readability-delete-null-pointer,readability-redundant-member-init,readability-redundant-string-init,readability-static-accessed-through-instance,readability-string-compare'
+Checks:            '-*,misc-unused-alias-decls,misc-unused-parameters,modernize-deprecated-headers,modernize-raw-string-literal,modernize-redundant-void-arg,modernize-use-bool-literals,modernize-use-default-member-init,modernize-use-emplace,modernize-use-equals-delete,modernize-use-noexcept,modernize-use-nullptr,modernize-use-override,modernize-use-using,performance-faster-string-find,performance-for-range-copy,performance-unnecessary-copy-initialization,readability-avoid-const-params-in-decls,readability-braces-around-statements,readability-container-size-empty,readability-delete-null-pointer,readability-redundant-member-init,readability-redundant-string-init,readability-static-accessed-through-instance,readability-string-compare'
 HeaderFilterRegex: '/(fairmq/)'

.devcontainer/devcontainer.json

@@ -0,0 +1,5 @@
+{
+  "image": "ghcr.io/fairrootgroup/fairmq-dev/fedora-38:latest",
+  "features": {
+  }
+}

.github/actions/setup-deps/action.yml

@@ -0,0 +1,78 @@
+name: Install dependencies
+description: Setup spack and install dependencies
+
+inputs:
+  gcc:
+    description: 'GCC version to use'
+    required: true
+  env:
+    description: 'Spack environment name (latest, boost187, tsan)'
+    default: 'latest'
+  fresh:
+    description: 'Use fresh concretization'
+    default: 'false'
+  push-gcc:
+    description: 'Push the freshly-built gcc node to the buildcache (buildcache workflow only)'
+    default: 'false'
+  push-token:
+    description: 'Token with packages:write, required when push-gcc is true'
+    default: ''
+
+runs:
+  using: composite
+  # Composite action step names are not shown in the UI (https://github.com/actions/runner/issues/1877),
+  # so we use ::group:: to make them visible.
+  steps:
+    - name: Setup spack
+      uses: spack/setup-spack@v3
+      with:
+        color: true
+        buildcache: true
+
+    - name: Find system compiler
+      shell: spack-bash {0}
+      run: |
+        echo "::group::Find system compiler"
+        spack compiler find
+        echo "::endgroup::"
+
+    - name: Add FairMQ buildcache mirror
+      shell: spack-bash {0}
+      run: |
+        echo "::group::Add FairMQ buildcache mirror"
+        spack mirror add --unsigned --type binary \
+          ghcr-buildcache oci://ghcr.io/fairrootgroup/fairmq-spack-buildcache
+        echo "::endgroup::"
+
+    - name: Install GCC
+      shell: spack-bash {0}
+      env:
+        GITHUB_TOKEN: ${{ inputs.push-token }}
+      run: |
+        echo "::group::Install GCC"
+        spack install ${{ inputs.fresh == 'true' && '--fresh' || '' }} gcc@${{ inputs.gcc }} target=x86_64_v3
+        gcc_hash=$(spack find --json gcc@${{ inputs.gcc }} target=x86_64_v3 | jq -r 'sort_by(.version | split(".") | map(tonumber)) | last | .hash')
+        if [ "${{ inputs.push-gcc }}" = "true" ]; then
+          # Push the gcc node now, BEFORE `spack compiler find` registers it as an
+          # external -- externals are excluded from `buildcache push`. This is what
+          # lets CI pull gcc from the cache (~1 min) instead of building it (~1 h).
+          # --allow-missing: when gcc itself was pulled from the cache, its
+          # build-time dependencies are not installed locally and would
+          # otherwise fail the push.
+          spack mirror set --oci-username ${{ github.actor }} --oci-password-variable GITHUB_TOKEN ghcr-buildcache
+          spack buildcache push --unsigned --allow-missing ghcr-buildcache /$gcc_hash
+        fi
+        spack compiler find "$(spack location -i /$gcc_hash)"
+        echo "::endgroup::"
+
+    - name: Install dependencies
+      shell: spack-bash {0}
+      run: |
+        echo "::group::Install dependencies"
+        spack repo add "$GITHUB_WORKSPACE/test/ci/spack_repo/fairmq_ci"
+        spack env create fairmq test/ci/spack-${{ inputs.env }}.yaml
+        spack -e fairmq add gcc@${{ inputs.gcc }}
+        spack -e fairmq config add "packages:all:require:'%gcc@${{ inputs.gcc }}'"
+        spack -e fairmq install --fail-fast ${{ inputs.fresh == 'true' && '--fresh' || '' }}
+        spack env activate --sh fairmq | grep '^export ' | sed 's/^export //;s/;$//' >> $GITHUB_ENV
+        echo "::endgroup::"

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    target-branch: "dev"
+    schedule:
+      interval: "monthly"
+  - package-ecosystem: "gitsubmodule"
+    directory: "/"
+    target-branch: "dev"
+    schedule:
+      interval: "monthly"

.github/workflows/buildcache.yml

@@ -0,0 +1,82 @@
+name: Spack Buildcache
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 3 * * 0'  # Weekly on Sunday at 3am UTC
+  push:
+    branches: [dev, master]
+    paths:
+      - 'test/ci/spack-*.yaml'
+      - 'test/ci/spack_repo/**'
+      - '.github/workflows/buildcache.yml'
+      - '.github/actions/setup-deps/**'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    if: github.repository == 'FairRootGroup/FairMQ'
+    name: ${{ matrix.env }}-gcc-${{ matrix.gcc }}
+    runs-on: ubuntu-24.04
+    permissions:
+      packages: write
+    strategy:
+      fail-fast: false
+      matrix:
+        gcc: ['12', '13', '14', '15']
+        env: ['latest']
+        include:
+          - gcc: '15'
+            env: 'boost187'
+          - gcc: '15'
+            env: 'tsan'
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup spack environment
+        uses: ./.github/actions/setup-deps
+        with:
+          gcc: ${{ matrix.gcc }}
+          env: ${{ matrix.env }}
+          fresh: 'true'
+          push-gcc: 'true'
+          push-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Push to buildcache
+        if: ${{ !cancelled() }}
+        shell: spack-bash {0}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          spack -e fairmq mirror set --oci-username ${{ github.actor }} --oci-password-variable GITHUB_TOKEN ghcr-buildcache
+          # --allow-missing: build-time dependencies of specs that were
+          # satisfied from the buildcache are not installed locally and
+          # would otherwise fail the whole push.
+          spack -e fairmq buildcache push --unsigned --allow-missing ghcr-buildcache
+
+  update-index:
+    if: github.repository == 'FairRootGroup/FairMQ' && !cancelled()
+    needs: build
+    runs-on: ubuntu-24.04
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    permissions:
+      packages: write
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup spack
+        uses: spack/setup-spack@v3
+        with:
+          color: true
+
+      - name: Update buildcache index
+        shell: spack-bash {0}
+        run: |
+          spack env create fairmq test/ci/spack-latest.yaml
+          spack -e fairmq mirror set --oci-username ${{ github.actor }} --oci-password-variable GITHUB_TOKEN ghcr-buildcache
+          spack -e fairmq buildcache update-index ghcr-buildcache

.github/workflows/check_metadata.yaml

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: 2023 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH, Darmstadt, Germany
+#
+# SPDX-License-Identifier: CC0-1.0
+
+name: Check AUTHORS and CONTRIBUTORS in metadata
+
+on:
+  push:
+    paths:
+    - AUTHORS
+    - CONTRIBUTORS
+    - codemeta.json
+    - .zenodo.json
+  pull_request:
+    paths:
+    - AUTHORS
+    - CONTRIBUTORS
+    - codemeta.json
+    - .zenodo.json
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Try updating metadata
+        run: python meta_update.py
+      - name: Check for Updates
+        run: git diff --exit-code

.github/workflows/ci.yml

@@ -0,0 +1,209 @@
+name: CI
+
+on:
+  push:
+    branches: [master, dev]
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    if: github.repository == 'FairRootGroup/FairMQ'
+    name: ${{ matrix.env }}-gcc-${{ matrix.gcc }}
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        gcc: ['12', '13', '14', '15']
+        env: ['latest']
+        include:
+          - gcc: '15'
+            env: 'boost187'
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: true
+          fetch-tags: true
+          fetch-depth: 0
+
+      - name: Setup spack environment
+        uses: ./.github/actions/setup-deps
+        with:
+          gcc: ${{ matrix.gcc }}
+          env: ${{ matrix.env }}
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@d62db5f07c26379fc4b4e0916f098a92573c3b03 # v1.2.23
+        with:
+          key: ${{ github.job }}-${{ matrix.env }}-gcc${{ matrix.gcc }}
+          max-size: 500M
+
+      - name: Configure and Build
+        uses: threeal/cmake-action@725d1314ccf9ea922805d7e3f9d9bcbca892b406 # v2.1.0
+        with:
+          generator: Ninja
+          options: |
+            CMAKE_BUILD_TYPE=RelWithDebInfo
+            CMAKE_INSTALL_PREFIX=${{ github.workspace }}/install
+            BUILD_TESTING=ON
+            CMAKE_C_COMPILER_LAUNCHER=ccache
+            CMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+      - name: Test
+        run: |
+          # Region/segment tests mlock() shared memory; raise the locked-memory
+          # limit so it does not hit RLIMIT_MEMLOCK on the runner.
+          sudo prlimit --pid $$ --memlock=unlimited:unlimited
+          ulimit -l
+          ctest --test-dir build --output-on-failure --no-tests=error
+
+      - name: Install
+        run: cmake --install build
+
+  sanitizers:
+    if: github.repository == 'FairRootGroup/FairMQ'
+    name: ${{ matrix.sanitizer.name }}
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        sanitizer:
+          - name: asan+lsan+ubsan
+            gcc: '14'
+            env: latest
+            options: |
+              ENABLE_SANITIZER_ADDRESS=ON
+              ENABLE_SANITIZER_LEAK=ON
+              ENABLE_SANITIZER_UNDEFINED_BEHAVIOR=ON
+            cxx-flags: -O1 -fno-omit-frame-pointer
+          - name: tsan
+            gcc: '15'
+            env: tsan
+            options: ENABLE_SANITIZER_THREAD=ON
+            cxx-flags: -fno-omit-frame-pointer
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: true
+          fetch-tags: true
+          fetch-depth: 0
+
+      - name: Setup spack environment
+        uses: ./.github/actions/setup-deps
+        with:
+          gcc: ${{ matrix.sanitizer.gcc }}
+          env: ${{ matrix.sanitizer.env }}
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@d62db5f07c26379fc4b4e0916f098a92573c3b03 # v1.2.23
+        with:
+          key: ${{ github.job }}-${{ matrix.sanitizer.name }}
+          max-size: 500M
+
+      - name: Locate instrumented libstdc++
+        if: matrix.sanitizer.name == 'tsan'
+        shell: spack-bash {0}
+        # The test processes must load the tsan-instrumented libstdc++
+        # instead of the compiler's own (same soname, LD_LIBRARY_PATH beats
+        # the RUNPATH). Set per test via ctest, not at the job level: like
+        # any shared library built with gcc -fsanitize=thread it has
+        # unresolved __tsan_* symbols, so loading it into uninstrumented
+        # tools (cmake, ctest, ninja) would break them.
+        run: |
+          prefix=$(spack -e fairmq location -i libstdcxx-tsan)
+          echo "test_library_path=$prefix/lib" >> $GITHUB_ENV
+
+      - name: Configure and Build
+        uses: threeal/cmake-action@725d1314ccf9ea922805d7e3f9d9bcbca892b406 # v2.1.0
+        with:
+          generator: Ninja
+          cxx-flags: ${{ matrix.sanitizer.cxx-flags }}
+          options: |
+            CMAKE_BUILD_TYPE=Debug
+            BUILD_TESTING=ON
+            CMAKE_C_COMPILER_LAUNCHER=ccache
+            CMAKE_CXX_COMPILER_LAUNCHER=ccache
+            FAIRMQ_TEST_LD_LIBRARY_PATH=${{ env.test_library_path }}
+            ${{ matrix.sanitizer.options }}
+
+      - name: Verify tsan instrumentation wiring
+        if: matrix.sanitizer.name == 'tsan'
+        shell: spack-bash {0}
+        run: |
+          set -x
+          # the test environment must resolve libstdc++ to the instrumented copy
+          LD_LIBRARY_PATH=$test_library_path ldd build/test/testsuite_Channel \
+            | grep 'libstdc++' | tee /dev/stderr | grep -q libstdcxx-tsan
+          # libzmq must be instrumented
+          nm -D --undefined-only "$(spack -e fairmq location -i libzmq)/lib/libzmq.so" \
+            | grep -q __tsan_
+          # the instrumented libstdc++ must match the compiler release exactly,
+          # or binaries may reference GLIBCXX versions the runtime lacks
+          # (--color=never: the CI config forces SPACK_COLOR=always, which
+          # would wrap the version in ANSI escapes)
+          test "$(spack --color=never -e fairmq find --format '{version}' libstdcxx-tsan)" \
+            = "$(g++ -dumpfullversion)"
+          # the LD_LIBRARY_PATH prepend must reach the registered tests
+          # (via a file: grep -q quits on first match, and SIGPIPE on the
+          # large json output would fail the step under pipefail)
+          ctest --test-dir build --show-only=json-v1 > ctest-show-only.json
+          grep -q libstdcxx-tsan ctest-show-only.json
+
+      - name: Test
+        run: |
+          # Region/segment tests mlock() shared memory; raise the locked-memory
+          # limit so it does not hit RLIMIT_MEMLOCK on the runner.
+          sudo prlimit --pid $$ --memlock=unlimited:unlimited
+          ulimit -l
+          ctest --test-dir build --output-on-failure --no-tests=error
+
+  static-analysis:
+    if: github.repository == 'FairRootGroup/FairMQ'
+    name: static-analysis
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: true
+          fetch-tags: true
+          fetch-depth: 0
+
+      - name: Setup spack environment
+        uses: ./.github/actions/setup-deps
+        with:
+          gcc: '14'
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@d62db5f07c26379fc4b4e0916f098a92573c3b03 # v1.2.23
+        with:
+          key: ${{ github.job }}
+          max-size: 500M
+
+      - name: Configure
+        run: |
+          cmake -S . -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DBUILD_TESTING=ON \
+            -DRUN_STATIC_ANALYSIS=ON \
+            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+      - name: Build
+        run: |
+          set -o pipefail
+          cmake --build build 2>&1 | tee build.log
+
+      - name: Check for warnings
+        run: |
+          test -f build.log || { echo "::error::build.log was not produced"; exit 1; }
+          if grep -q "warning:" build.log; then
+            echo "::error::Static analysis found warnings"
+            grep "warning:" build.log
+            exit 1
+          fi

.github/workflows/codemeta_validate.yaml

@@ -16,6 +16,6 @@ jobs:
     container:
       image: gitlab-registry.in2p3.fr/escape2020/wp3/eossr:v1.0
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: validate codemeta
         run: eossr-metadata-validator codemeta.json

CMakeLists.txt

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (C) 2018-2023 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
+# Copyright (C) 2018-2024 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
 #                                                                              #
 #              This software is distributed under the terms of the             #
 #              GNU Lesser General Public Licence (LGPL) version 3,             #
@@ -8,8 +8,7 @@
 
 
 # Project ######################################################################
-cmake_minimum_required(VERSION 3.15 FATAL_ERROR)
-cmake_policy(VERSION 3.15...3.26)
+cmake_minimum_required(VERSION 3.15...3.30 FATAL_ERROR)
 
 list(PREPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
 include(GitHelper)
@@ -47,6 +46,13 @@ include(FairMQDependencies)
 
 
 # Targets ######################################################################
+if(FAIRMQ_TEST_LD_LIBRARY_PATH AND CMAKE_VERSION VERSION_LESS 3.22)
+  # The per-test injection relies on ctest's ENVIRONMENT_MODIFICATION, which
+  # older CMake silently drops -- the tests would run against the default
+  # runtime while looking green.
+  message(FATAL_ERROR "FAIRMQ_TEST_LD_LIBRARY_PATH requires CMake >= 3.22")
+endif()
+
 if(BUILD_FAIRMQ)
   add_subdirectory(fairmq)
 endif()

FairMQTest.cmake

@@ -1,93 +0,0 @@
-################################################################################
-# Copyright (C) 2021-2023 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"                       #
-################################################################################
-
-cmake_host_system_information(RESULT fqdn QUERY FQDN)
-
-set(CTEST_SOURCE_DIRECTORY .)
-set(CTEST_BINARY_DIRECTORY build)
-set(CTEST_CMAKE_GENERATOR "Ninja")
-set(CTEST_USE_LAUNCHERS ON)
-set(CTEST_CONFIGURATION_TYPE "RelWithDebInfo")
-set(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE 102400)
-
-if(NOT NCPUS)
-  if(ENV{SLURM_CPUS_PER_TASK})
-    set(NCPUS $ENV{SLURM_CPUS_PER_TASK})
-  else()
-    include(ProcessorCount)
-    ProcessorCount(NCPUS)
-    if(NCPUS EQUAL 0)
-      set(NCPUS 1)
-    endif()
-  endif()
-endif()
-
-if ("$ENV{CTEST_SITE}" STREQUAL "")
-  set(CTEST_SITE "${fqdn}")
-else()
-  set(CTEST_SITE $ENV{CTEST_SITE})
-endif()
-
-if ("$ENV{LABEL}" STREQUAL "")
-  set(CTEST_BUILD_NAME "build")
-else()
-  set(CTEST_BUILD_NAME $ENV{LABEL})
-endif()
-
-ctest_start(Continuous)
-
-list(APPEND options "-DDISABLE_COLOR=ON" "-DBUILD_EXAMPLES=ON" "-DBUILD_TESTING=ON")
-if(RUN_STATIC_ANALYSIS)
-  list(APPEND options "-DRUN_STATIC_ANALYSIS=ON")
-endif()
-if(CMAKE_BUILD_TYPE)
-  set(CTEST_CONFIGURATION_TYPE ${CMAKE_BUILD_TYPE})
-endif()
-if(ENABLE_SANITIZER_ADDRESS)
-  list(APPEND options "-DENABLE_SANITIZER_ADDRESS=ON")
-endif()
-if(ENABLE_SANITIZER_LEAK)
-  list(APPEND options "-DENABLE_SANITIZER_LEAK=ON")
-endif()
-if(ENABLE_SANITIZER_UNDEFINED_BEHAVIOR)
-  list(APPEND options "-DENABLE_SANITIZER_UNDEFINED_BEHAVIOR=ON")
-endif()
-if(ENABLE_SANITIZER_MEMORY)
-  list(APPEND options "-DENABLE_SANITIZER_MEMORY=ON")
-endif()
-if(ENABLE_SANITIZER_THREAD)
-  list(APPEND options "-DENABLE_SANITIZER_THREAD=ON")
-endif()
-if(CMAKE_CXX_COMPILER)
-  list(APPEND options "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
-endif()
-if(CMAKE_CXX_FLAGS)
-  list(APPEND options "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}")
-endif()
-list(REMOVE_DUPLICATES options)
-list(JOIN options ";" optionsstr)
-ctest_configure(OPTIONS "${optionsstr}")
-
-ctest_submit()
-
-ctest_build(FLAGS "-j${NCPUS}")
-
-ctest_submit()
-
-if(NOT RUN_STATIC_ANALYSIS)
-  ctest_test(BUILD "${CTEST_BINARY_DIRECTORY}"
-             PARALLEL_LEVEL ${NCPUS}
-             SCHEDULE_RANDOM ON
-             RETURN_VALUE _ctest_test_ret_val)
-
-  ctest_submit()
-endif()
-
-if(_ctest_test_ret_val)
-  Message(FATAL_ERROR "Some tests failed.")
-endif()

Jenkinsfile

@@ -1,114 +0,0 @@
-#!groovy
-
-def jobMatrix(String type, List specs) {
-  def nodes = [:]
-  for (spec in specs) {
-    def job = ""
-    def selector = "slurm"
-    def os = ""
-    def ver = ""
-
-    if (type == 'build') {
-      job = "${spec.os}-${spec.ver}-${spec.arch}-${spec.compiler}"
-      if (spec.os =~ /^macos/) {
-        selector = "${spec.os}-${spec.ver}-${spec.arch}"
-      }
-      os = spec.os
-      ver = spec.ver
-    } else { // == 'check'
-      job = "${spec.name}"
-      os = 'fedora'
-      ver = '36'
-    }
-
-    def label = "${job}"
-    def extra = spec.extra
-
-    nodes[label] = {
-      node(selector) {
-        githubNotify(context: "${label}", description: 'Building ...', status: 'PENDING')
-        try {
-          deleteDir()
-          checkout scm
-
-          def jobscript = 'job.sh'
-          def ctestcmd = "ctest ${extra} -S FairMQTest.cmake -V --output-on-failure"
-          sh "echo \"set -e\" >> ${jobscript}"
-          sh "echo \"export LABEL=\\\"\${JOB_BASE_NAME} ${label}\\\"\" >> ${jobscript}"
-          if (selector =~ /^macos/) {
-            sh """\
-              echo \"${ctestcmd}\" >> ${jobscript}
-            """
-            sh "cat ${jobscript}"
-            sh "bash ${jobscript}"
-          } else { // selector == "slurm"
-            def imageurl = "oras://ghcr.io/fairrootgroup/fairmq-dev/${os}-${ver}-sif:latest"
-            def execopts = "--net --ipc --uts --pid -B/shared"
-            def containercmd = "singularity exec ${execopts} ${imageurl} bash -l -c \\\"${ctestcmd} ${extra}\\\""
-            sh """\
-              echo \"echo \\\"*** Job started at .......: \\\$(date -R)\\\"\" >> ${jobscript}
-              echo \"echo \\\"*** Job ID ...............: \\\${SLURM_JOB_ID}\\\"\" >> ${jobscript}
-              echo \"echo \\\"*** Compute node .........: \\\$(hostname -f)\\\"\" >> ${jobscript}
-              echo \"unset http_proxy\" >> ${jobscript}
-              echo \"unset HTTP_PROXY\" >> ${jobscript}
-              echo \"${containercmd}\" >> ${jobscript}
-            """
-            sh "cat ${jobscript}"
-            sh "test/ci/slurm-submit.sh \"FairMQ \${JOB_BASE_NAME} ${label}\" ${jobscript}"
-
-            if (job == "static-analyzers") {
-              recordIssues(enabledForFailure: true,
-                           tools: [gcc(pattern: 'build/Testing/Temporary/*.log')],
-                           filters: [excludeFile('extern/*'), excludeFile('usr/*')],
-                           skipBlames: true,
-                           skipPublishingChecks: true)
-            }
-          }
-
-          deleteDir()
-          githubNotify(context: "${label}", description: 'Success', status: 'SUCCESS')
-        } catch (e) {
-          deleteDir()
-          githubNotify(context: "${label}", description: 'Error', status: 'ERROR')
-          throw e
-        }
-      }
-    }
-  }
-  return nodes
-}
-
-pipeline{
-  agent none
-  stages {
-    stage("CI") {
-      steps{
-        script {
-          def builds = jobMatrix('build', [
-            [os: 'ubuntu', ver: '20.04', arch: 'x86_64', compiler: 'gcc-9'],
-            [os: 'ubuntu', ver: '22.04', arch: 'x86_64', compiler: 'gcc-11'],
-            [os: 'fedora', ver: '33',    arch: 'x86_64', compiler: 'gcc-10'],
-            [os: 'fedora', ver: '34',    arch: 'x86_64', compiler: 'gcc-11'],
-            [os: 'fedora', ver: '35',    arch: 'x86_64', compiler: 'gcc-11'],
-            [os: 'fedora', ver: '36',    arch: 'x86_64', compiler: 'gcc-12'],
-            [os: 'fedora', ver: '37',    arch: 'x86_64', compiler: 'gcc-12'],
-            [os: 'fedora', ver: '38',    arch: 'x86_64', compiler: 'gcc-13'],
-            [os: 'macos',  ver: '12',    arch: 'x86_64', compiler: 'apple-clang-14'],
-            [os: 'macos',  ver: '13',    arch: 'arm64',  compiler: 'apple-clang-14'],
-          ])
-
-          def all_debug = "-DCMAKE_BUILD_TYPE=Debug"
-
-          def checks = jobMatrix('check', [
-            [name: 'static-analyzers', extra: "${all_debug} -DRUN_STATIC_ANALYSIS=ON"],
-            [name: '{address,leak,ub}-sanitizers',
-             extra: "${all_debug} -DENABLE_SANITIZER_ADDRESS=ON -DENABLE_SANITIZER_LEAK=ON -DENABLE_SANITIZER_UNDEFINED_BEHAVIOUR=ON -DCMAKE_CXX_FLAGS='-O1 -fno-omit-frame-pointer'"],
-            [name: 'thread-sanitizer', extra: "${all_debug} -DENABLE_SANITIZER_THREAD=ON -DCMAKE_CXX_COMPILER=clang++"],
-          ])
-
-          parallel(builds + checks)
-        }
-      }
-    }
-  }
-}

README.md

@@ -45,9 +45,9 @@ Recommended:
 
 ```bash
 git clone https://github.com/FairRootGroup/FairMQ fairmq_source
-cmake -S fairmq_source -B fairmq_build -GNinja -DCMAKE_BUILD_TYPE=Release
+cmake -S fairmq_source -B fairmq_build -GNinja -DCMAKE_BUILD_TYPE=Release [-DBUILD_TESTING=ON]
 cmake --build fairmq_build
-ctest --test-dir fairmq_build --output-on-failure --schedule-random -j<ncpus>
+[ctest --test-dir fairmq_build --output-on-failure --schedule-random -j<ncpus>] # needs -DBUILD_TESTING=ON
 cmake --install fairmq_build --prefix $(pwd)/fairmq_install
 ```
 
@@ -56,6 +56,24 @@ Please consult the [manpages of your CMake version](https://cmake.org/cmake/help
 If dependencies are not installed in standard system directories, you can hint the installation location via
 `-DCMAKE_PREFIX_PATH=...` or per dependency via `-D{DEPENDENCY}_ROOT=...` (`*_ROOT` variables can also be environment variables).
 
+## Installation via Spack
+
+Prerequisite: [Spack](https://spack.readthedocs.io/en/latest/getting_started.html)
+
+```bash
+spack info fairmq # inspect build options
+spack install fairmq # build latest packaged version with default options
+```
+
+Build FairMQ's dependencies via Spack for development:
+```bash
+git clone -b dev https://github.com/FairRootGroup/FairMQ fairmq_source
+spack --env fairmq_source install # installs deps declared in fairmq_source/spack.yaml
+spack env activate fairmq_source # sets $CMAKE_PREFIX_PATH which is used by CMake to find FairMQ's deps
+cmake -S fairmq_source -B fairmq_build -GNinja -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON
+# develop, compile, test
+spack env deactivate # at end of dev session, or simply close the shell
+```
 
 ## Usage
 

cmake/FairMQBundlePackageHelper.cmake

@@ -68,6 +68,7 @@ function(build_bundled package bundle)
 
     exec(${CMAKE_COMMAND} -S ${${package}_SOURCE_DIR} -B ${${package}_BINARY_DIR} -G ${CMAKE_GENERATOR}
       -DCMAKE_INSTALL_PREFIX=${${package}_INSTALL_DIR} -DBUILD_GMOCK=OFF
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
     )
     exec(${CMAKE_COMMAND} --build ${${package}_BINARY_DIR})
     exec(${CMAKE_COMMAND} --build ${${package}_BINARY_DIR} --target install)

cmake/FairMQDependencies.cmake

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (C) 2018-2023 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
+# Copyright (C) 2018-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
 #                                                                              #
 #              This software is distributed under the terms of the             #
 #              GNU Lesser General Public Licence (LGPL) version 3,             #
@@ -23,6 +23,18 @@ if(BUILD_FAIRMQ OR BUILD_TIDY_TOOL)
   find_package2(PUBLIC Boost REQUIRED VERSION 1.66
     COMPONENTS container program_options filesystem date_time regex
   )
+
+  # Check Boost.Process compatibility
+  # Boost 1.88 has broken Boost.Process v2 without v1 compatibility headers
+  # Boost 1.89+ provides <boost/process/v1.hpp> for the old API
+  if(Boost_VERSION VERSION_EQUAL "1.88.0")
+    message(FATAL_ERROR "Boost version 1.88 is not supported due to Boost.Process API changes. "
+                        "Please use Boost < 1.88 or >= 1.89")
+  endif()
+
+  if(Boost_VERSION VERSION_GREATER_EQUAL "1.89")
+    set(FAIRMQ_BOOST_PROCESS_V1_HEADER ON CACHE INTERNAL "Use boost/process/v1.hpp for Boost >= 1.89")
+  endif()
 endif()
 
 if(BUILD_FAIRMQ)
@@ -41,7 +53,7 @@ if(BUILD_TESTING)
   endif()
   find_package2(BUNDLED GTest REQUIRED)
   if(GTest_BUNDLED)
-    set(GTest_VERSION "Apr 8 2022 @a1cc8c55")
+    set(GTest_VERSION "Dec 26 2024 @7d76a23")
     set(GTest_PREFIX "<bundled>")
   endif()
 endif()

cmake/FairMQProjectSettings.cmake

@@ -54,8 +54,8 @@ endif()
 list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_LIBDIR}" isSystemDir)
 if("${isSystemDir}" STREQUAL "-1")
   if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    list(APPEND CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-new-dtags")
-    list(APPEND CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-new-dtags")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,--enable-new-dtags")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS " -Wl,--enable-new-dtags")
     list(PREPEND CMAKE_INSTALL_RPATH "$ORIGIN/../${PROJECT_INSTALL_LIBDIR}")
   elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     list(PREPEND CMAKE_INSTALL_RPATH "@loader_path/../${PROJECT_INSTALL_LIBDIR}")

examples/CMakeLists.txt

@@ -12,6 +12,22 @@ set(test_script_prefix "test-ex")
 set(testsuite "Example")
 set(transports "zeromq" "shmem")
 
+# Environment for every example test (directory scope, so the subdirectories
+# see it too)
+set(env_mods)
+if(ENABLE_SANITIZER_LEAK AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.22)
+  get_filename_component(lsan_supps "${CMAKE_SOURCE_DIR}/test/leak_sanitizer_suppressions.txt" ABSOLUTE)
+  list(APPEND env_mods "LSAN_OPTIONS=set:suppressions=${lsan_supps}")
+endif()
+# Run the example tests against an alternative runtime library directory as
+# well (see test/CMakeLists.txt). The test scripts only launch instrumented
+# binaries (bash itself does not link libstdc++). Note: unlike the
+# testsuites, the example binaries get no locale-cache warmup -- their
+# main() comes from the installed public header fairmq/runDevice.h.
+if(FAIRMQ_TEST_LD_LIBRARY_PATH)
+  list(APPEND env_mods "LD_LIBRARY_PATH=path_list_prepend:${FAIRMQ_TEST_LD_LIBRARY_PATH}")
+endif()
+
 function(add_example)
   cmake_parse_arguments(PARSE_ARGV 0 ARG
     "CONFIG;NO_TRANSPORT;NO_TEST"
@@ -29,11 +45,6 @@ function(add_example)
     message(FATAL_ERROR "NAME arg is required")
   endif()
 
-  if(ENABLE_SANITIZER_LEAK AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.22)
-    get_filename_component(lsan_supps "${CMAKE_SOURCE_DIR}/test/leak_sanitizer_suppressions.txt" ABSOLUTE)
-    set(lsan_options "LSAN_OPTIONS=set:suppressions=${lsan_supps}")
-  endif()
-
   if(ARG_DEVICE)
     set(exe_targets)
     foreach(device IN LISTS ARG_DEVICE)
@@ -61,7 +72,7 @@ function(add_example)
   set(FAIRMQ_BIN_DIR ${CMAKE_BINARY_DIR}/fairmq)
   foreach(script IN LISTS scripts)
     set(script_file "${script_prefix}-${script}.sh")
-    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${script_file}.in" "${CMAKE_CURRENT_BINARY_DIR}/${script_file}")
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${script_file}.in" "${CMAKE_CURRENT_BINARY_DIR}/${script_file}" @ONLY)
   endforeach()
 
   if(ARG_CONFIG)
@@ -78,8 +89,8 @@ function(add_example)
       set(test "${testsuite}.${name}.${transport}")
       add_test(NAME ${test} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${test_script} ${transport})
       set_tests_properties(${test} PROPERTIES TIMEOUT "30")
-      if(lsan_options)
-        set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION ${lsan_options})
+      if(env_mods)
+        set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION "${env_mods}")
       endif()
     else()
       foreach(transport IN LISTS transports)
@@ -88,16 +99,16 @@ function(add_example)
             set(test "${testsuite}.${name}.${variant}.${transport}")
             add_test(NAME ${test} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${test_script} ${transport} ${variant})
             set_tests_properties(${test} PROPERTIES TIMEOUT "30")
-            if(lsan_options)
-              set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION ${lsan_options})
+            if(env_mods)
+              set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION "${env_mods}")
             endif()
           endforeach()
         else()
           set(test "${testsuite}.${name}.${transport}")
           add_test(NAME ${test} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${test_script} ${transport})
           set_tests_properties(${test} PROPERTIES TIMEOUT "30")
-          if(lsan_options)
-            set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION ${lsan_options})
+          if(env_mods)
+            set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION "${env_mods}")
           endif()
         endif()
       endforeach()
@@ -119,7 +130,7 @@ function(add_example)
   set(FAIRMQ_BIN_DIR ${CMAKE_INSTALL_PREFIX}/${PROJECT_INSTALL_BINDIR}/fairmq)
   foreach(script IN LISTS scripts)
     set(script_file "${script_prefix}-${script}.sh")
-    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${script_file}.in" "${CMAKE_CURRENT_BINARY_DIR}/${script_file}_install")
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${script_file}.in" "${CMAKE_CURRENT_BINARY_DIR}/${script_file}_install" @ONLY)
     install(
       PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/${script_file}_install"
       DESTINATION ${PROJECT_INSTALL_BINDIR}

examples/custom-controller/CMakeLists.txt

@@ -15,6 +15,8 @@ set_target_properties(${exe} PROPERTIES ENABLE_EXPORTS ON)
 set(test "${testsuite}.${name}")
 add_test(NAME ${test} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${exe})
 set_tests_properties(${test} PROPERTIES TIMEOUT 30)
-if(lsan_options)
-  set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION ${lsan_options})
+# (the previous `if(lsan_options)` here could never fire -- that variable
+# only ever existed in the add_example() function scope)
+if(env_mods)
+  set_tests_properties(${test} PROPERTIES ENVIRONMENT_MODIFICATION "${env_mods}")
 endif()

examples/region/CMakeLists.txt

@@ -8,5 +8,5 @@
 
 add_example(NAME region
   DEVICE sampler processor sink keep-alive
-  SCRIPT region region-advanced
+  SCRIPT region region-advanced region-advanced-external
 )

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

@@ -0,0 +1,95 @@
+#!/bin/bash
+
+export FAIRMQ_PATH=@FAIRMQ_BIN_DIR@
+
+transport=${1:-shmem}
+msgSize=${2:-1000000}
+
+SAMPLER="fairmq-ex-region-sampler"
+SAMPLER+=" --id sampler1"
+# SAMPLER+=" --sampling-rate 10"
+SAMPLER+=" --severity debug"
+SAMPLER+=" --msg-size $msgSize"
+SAMPLER+=" --transport $transport"
+SAMPLER+=" --shmid 1"
+SAMPLER+=" --shm-monitor false"
+SAMPLER+=" --rc-segment-size 200000000"
+SAMPLER+=" --external-region true"
+SAMPLER+=" --shm-no-cleanup true"
+SAMPLER+=" --chan-name data1"
+SAMPLER+=" --channel-config name=data1,type=push,method=bind,address=tcp://127.0.0.1:7777"
+xterm -geometry 90x60+0+0 -hold -e @EX_BIN_DIR@/$SAMPLER &
+
+PROCESSOR1="fairmq-ex-region-processor"
+PROCESSOR1+=" --id processor1"
+PROCESSOR1+=" --severity debug"
+PROCESSOR1+=" --transport $transport"
+PROCESSOR1+=" --shmid 1"
+PROCESSOR1+=" --shm-segment-id 1"
+PROCESSOR1+=" --shm-monitor false"
+PROCESSOR1+=" --shm-no-cleanup true"
+PROCESSOR1+=" --channel-config name=data1,type=pull,method=connect,address=tcp://127.0.0.1:7777"
+PROCESSOR1+="                  name=data2,type=push,method=bind,address=tcp://127.0.0.1:7778"
+PROCESSOR1+="                  name=data3,type=push,method=bind,address=tcp://127.0.0.1:7779"
+xterm -geometry 90x40+550+40 -hold -e @EX_BIN_DIR@/$PROCESSOR1 &
+
+PROCESSOR2="fairmq-ex-region-processor"
+PROCESSOR2+=" --id processor2"
+PROCESSOR2+=" --severity debug"
+PROCESSOR2+=" --transport $transport"
+PROCESSOR2+=" --shmid 1"
+PROCESSOR2+=" --shm-segment-id 2"
+PROCESSOR2+=" --shm-monitor false"
+PROCESSOR2+=" --shm-no-cleanup true"
+PROCESSOR2+=" --channel-config name=data1,type=pull,method=connect,address=tcp://127.0.0.1:7777"
+PROCESSOR2+="                  name=data2,type=push,method=bind,address=tcp://127.0.0.1:7788"
+PROCESSOR2+="                  name=data3,type=push,method=bind,address=tcp://127.0.0.1:7789"
+xterm -geometry 90x40+550+600 -hold -e @EX_BIN_DIR@/$PROCESSOR2 &
+
+SINK1_1="fairmq-ex-region-sink"
+SINK1_1+=" --id sink1_1"
+SINK1_1+=" --severity debug"
+SINK1_1+=" --chan-name data2"
+SINK1_1+=" --transport $transport"
+SINK1_1+=" --shmid 1"
+SINK1_1+=" --shm-segment-id 1"
+SINK1_1+=" --shm-monitor false"
+SINK1_1+=" --shm-no-cleanup true"
+SINK1_1+=" --channel-config name=data2,type=pull,method=connect,address=tcp://127.0.0.1:7778"
+xterm -geometry 90x20+1100+0 -hold -e @EX_BIN_DIR@/$SINK1_1 &
+
+SINK1_2="fairmq-ex-region-sink"
+SINK1_2+=" --id sink1_2"
+SINK1_2+=" --severity debug"
+SINK1_2+=" --chan-name data3"
+SINK1_2+=" --transport $transport"
+SINK1_2+=" --shmid 1"
+SINK1_2+=" --shm-segment-id 1"
+SINK1_2+=" --shm-monitor false"
+SINK1_2+=" --shm-no-cleanup true"
+SINK1_2+=" --channel-config name=data3,type=pull,method=connect,address=tcp://127.0.0.1:7779"
+xterm -geometry 90x20+1100+300 -hold -e @EX_BIN_DIR@/$SINK1_2 &
+
+SINK2_1="fairmq-ex-region-sink"
+SINK2_1+=" --id sink2_1"
+SINK2_1+=" --severity debug"
+SINK2_1+=" --chan-name data2"
+SINK2_1+=" --transport $transport"
+SINK2_1+=" --shmid 1"
+SINK2_1+=" --shm-segment-id 2"
+SINK2_1+=" --shm-monitor false"
+SINK2_1+=" --shm-no-cleanup true"
+SINK2_1+=" --channel-config name=data2,type=pull,method=connect,address=tcp://127.0.0.1:7788"
+xterm -geometry 90x20+1100+600 -hold -e @EX_BIN_DIR@/$SINK2_1 &
+
+SINK2_2="fairmq-ex-region-sink"
+SINK2_2+=" --id sink2_2"
+SINK2_2+=" --severity debug"
+SINK2_2+=" --chan-name data3"
+SINK2_2+=" --transport $transport"
+SINK2_2+=" --shmid 1"
+SINK2_2+=" --shm-segment-id 2"
+SINK2_2+=" --shm-monitor false"
+SINK2_2+=" --shm-no-cleanup true"
+SINK2_2+=" --channel-config name=data3,type=pull,method=connect,address=tcp://127.0.0.1:7789"
+xterm -geometry 90x20+1100+900 -hold -e @EX_BIN_DIR@/$SINK2_2 &

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

@@ -2,16 +2,8 @@
 
 export FAIRMQ_PATH=@FAIRMQ_BIN_DIR@
 
-transport="shmem"
-msgSize="1000000"
-
-if [[ $1 =~ ^[a-z]+$ ]]; then
-    transport=$1
-fi
-
-if [[ $2 =~ ^[0-9]+$ ]]; then
-    msgSize=$1
-fi
+transport=${1:-shmem}
+msgSize=${2:-1000000}
 
 SAMPLER="fairmq-ex-region-sampler"
 SAMPLER+=" --id sampler1"
@@ -19,6 +11,7 @@ SAMPLER+=" --id sampler1"
 SAMPLER+=" --severity debug"
 SAMPLER+=" --msg-size $msgSize"
 SAMPLER+=" --transport $transport"
+#SAMPLER+=" --rc-segment-size 0"
 SAMPLER+=" --shm-monitor true"
 SAMPLER+=" --chan-name data1"
 SAMPLER+=" --channel-config name=data1,type=push,method=bind,address=tcp://127.0.0.1:7777"

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

@@ -2,16 +2,8 @@
 
 export FAIRMQ_PATH=@FAIRMQ_BIN_DIR@
 
-transport="shmem"
-msgSize="1000000"
-
-if [[ $1 =~ ^[a-z]+$ ]]; then
-    transport=$1
-fi
-
-if [[ $2 =~ ^[0-9]+$ ]]; then
-    msgSize=$1
-fi
+transport=${1:-shmem}
+msgSize=${2:-1000000}
 
 SAMPLER="fairmq-ex-region-sampler"
 SAMPLER+=" --id sampler1"

examples/region/keep-alive.cxx

@@ -95,10 +95,11 @@ struct ShmManager
             uint64_t size = stoull(conf.at(1));
             fair::mq::RegionConfig cfg;
             cfg.id = id;
+            cfg.rcSegmentSize = 0;
             cfg.size = size;
             regionCfgs.push_back(cfg);
 
-            auto ret = regions.emplace(id, make_unique<fair::mq::shmem::UnmanagedRegion>(shmId, id, size));
+            auto ret = regions.emplace(id, make_unique<fair::mq::shmem::UnmanagedRegion>(shmId, cfg));
             fair::mq::shmem::UnmanagedRegion& region = *(ret.first->second);
             LOG(info) << "Created unamanged region " << id << " of size " << region.GetSize()
                       << ", starting at " << region.GetData() << ". Locking...";

fairmq/CMakeLists.txt

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (C) 2012-2023 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
+# Copyright (C) 2012-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  #
 #                                                                              #
 #              This software is distributed under the terms of the             #
 #              GNU Lesser General Public Licence (LGPL) version 3,             #
@@ -63,14 +63,21 @@ if(BUILD_FAIRMQ)
     Tools.h
     TransportFactory.h
     Transports.h
+    TransportEnum.h
     UnmanagedRegion.h
     options/FairMQProgOptions.h
     runDevice.h
     runFairMQDevice.h
     shmem/Common.h
+    shmem/Manager.h
+    shmem/Message.h
     shmem/Monitor.h
+    shmem/Poller.h
     shmem/Segment.h
+    shmem/Socket.h
+    shmem/TransportFactory.h
     shmem/UnmanagedRegion.h
+    shmem/UnmanagedRegionImpl.h
     tools/Compiler.h
     tools/CppSTL.h
     tools/Exceptions.h
@@ -95,12 +102,6 @@ if(BUILD_FAIRMQ)
     plugins/Builtin.h
     plugins/config/Config.h
     plugins/control/Control.h
-    shmem/Message.h
-    shmem/Poller.h
-    shmem/UnmanagedRegionImpl.h
-    shmem/Socket.h
-    shmem/TransportFactory.h
-    shmem/Manager.h
     zeromq/Common.h
     zeromq/Context.h
     zeromq/Message.h
@@ -118,6 +119,7 @@ if(BUILD_FAIRMQ)
     Channel.cxx
     Device.cxx
     DeviceRunner.cxx
+    EventManager.cxx
     JSONParser.cxx
     MemoryResources.cxx
     Plugin.cxx
@@ -174,6 +176,9 @@ if(BUILD_FAIRMQ)
     FAIRMQ_HAS_STD_FILESYSTEM=${FAIRMQ_HAS_STD_FILESYSTEM}
     FAIRMQ_HAS_STD_PMR=${FAIRMQ_HAS_STD_PMR}
   )
+  if(FAIRMQ_BOOST_PROCESS_V1_HEADER)
+    target_compile_definitions(${target} PRIVATE FAIRMQ_BOOST_PROCESS_V1_HEADER)
+  endif()
   if(DEFINED FAIRMQ_CHANNEL_DEFAULT_AUTOBIND)
     # translate CMake boolean (TRUE, FALSE, 0, 1, OFF, ON) into C++ boolean literal (true, false)
     if(FAIRMQ_CHANNEL_DEFAULT_AUTOBIND)

fairmq/Channel.cxx

@@ -12,6 +12,7 @@
 #include <fairmq/Channel.h>
 #include <fairmq/Properties.h>
 #include <fairmq/Tools.h>
+#include <fairmq/Transports.h>
 #include <random>
 #include <regex>
 #include <set>
@@ -180,7 +181,8 @@ try {
 
     // validate channel name
     smatch m;
-    if (regex_search(fName, m, regex("[^a-zA-Z0-9\\-_\\[\\]#]"))) {
+    static regex const invalidName(R"([^a-zA-Z0-9\-_\[\]#])");
+    if (regex_search(fName, m, invalidName)) {
         ss << "INVALID";
         LOG(debug) << ss.str();
         LOG(error) << "channel name contains illegal character: '" << m.str(0) << "', allowed characters are: a-z, A-Z, 0-9, -, _, [, ], #";
@@ -383,4 +385,10 @@ bool Channel::BindEndpoint(string& endpoint)
     }
 }
 
+std::string Channel::GetTransportName() const { return TransportName(fTransportType); }
+
+Transport Channel::GetTransportType() const { return fTransportType; }
+
+void Channel::UpdateTransport(const std::string& transport) { fTransportType = TransportType(transport); Invalidate(); }
+
 } // namespace fair::mq

fairmq/Channel.h

@@ -14,7 +14,7 @@
 #include <fairmq/Properties.h>
 #include <fairmq/Socket.h>
 #include <fairmq/TransportFactory.h>
-#include <fairmq/Transports.h>
+#include <fairmq/TransportEnum.h>
 #include <fairmq/UnmanagedRegion.h>
 
 #include <cstdint>   // int64_t
@@ -145,11 +145,11 @@ class Channel
 
     /// Get channel transport name ("default", "zeromq" or "shmem")
     /// @return Returns channel transport name (e.g. "default", "zeromq" or "shmem")
-    std::string GetTransportName() const { return TransportName(fTransportType); }
+    std::string GetTransportName() const;
 
     /// Get channel transport type
     /// @return Returns channel transport type
-    mq::Transport GetTransportType() const { return fTransportType; }
+    mq::Transport GetTransportType() const;
 
     /// Get socket send buffer size (in number of messages)
     /// @return Returns socket send buffer size (in number of messages)
@@ -221,7 +221,7 @@ class Channel
 
     /// Set channel transport
     /// @param transport transport string ("default", "zeromq" or "shmem")
-    void UpdateTransport(const std::string& transport) { fTransportType = TransportType(transport); Invalidate(); }
+    void UpdateTransport(const std::string& transport);
 
     /// Set socket send buffer size
     /// @param sndBufSize Socket send buffer size (in number of messages)
@@ -438,7 +438,7 @@ class Channel
     }
 
     void CheckSendCompatibility(Parts& parts) { CheckSendCompatibility(parts.fParts); }
-    void CheckSendCompatibility(std::vector<MessagePtr>& msgVec)
+    void CheckSendCompatibility(Parts::container & msgVec)
     {
         for (auto& msg : msgVec) {
             if (fTransportType != msg->GetType()) {
@@ -468,7 +468,7 @@ class Channel
     }
 
     void CheckReceiveCompatibility(Parts& parts) { CheckReceiveCompatibility(parts.fParts); }
-    void CheckReceiveCompatibility(std::vector<MessagePtr>& msgVec)
+    void CheckReceiveCompatibility(Parts::container& msgVec)
     {
         for (auto& msg : msgVec) {
             if (fTransportType != msg->GetType()) {

fairmq/Device.cxx

@@ -9,6 +9,7 @@
 // FairMQ
 #include <fairmq/Device.h>
 #include <fairmq/Tools.h>
+#include <fairmq/Transports.h>
 
 // boost
 #include <boost/algorithm/string.hpp>   // join/split
@@ -512,7 +513,8 @@ void Device::HandleMultipleTransportInput()
     fMultitransportProceed = true;
 
     for (const auto& i : fMultitransportInputs) {
-        threads.emplace_back(thread(&Device::PollForTransport, this, fTransports.at(i.first).get(), i.second));
+        threads.emplace_back(
+            &Device::PollForTransport, this, fTransports.at(i.first).get(), i.second);
     }
 
     for (thread& t : threads) {

fairmq/Device.h

@@ -19,7 +19,7 @@
 #include <fairmq/StateQueue.h>
 #include <fairmq/Tools.h>
 #include <fairmq/TransportFactory.h>
-#include <fairmq/Transports.h>
+#include <fairmq/TransportEnum.h>
 #include <fairmq/UnmanagedRegion.h>
 
 // logger

fairmq/DeviceRunner.cxx

@@ -65,11 +65,14 @@ bool DeviceRunner::HandleGeneralOptions(const fair::mq::ProgOptions& config, boo
 
         if (printLogo) {
             LOG(info) << endl
-                << "      ______      _    _______  _________ " << endl
-                << "     / ____/___ _(_)_______   |/  /_  __ \\    version " << FAIRMQ_GIT_VERSION << endl
-                << "    / /_  / __ `/ / ___/__  /|_/ /_  / / /    build " << FAIRMQ_BUILD_TYPE << endl
-                << "   / __/ / /_/ / / /    _  /  / / / /_/ /     " << FAIRMQ_REPO_URL << endl
-                << "  /_/    \\__,_/_/_/     /_/  /_/  \\___\\_\\     " << FAIRMQ_LICENSE << "  © " << FAIRMQ_COPYRIGHT << endl;
+                      << "      ______      _    _______  _________ " << endl
+                      << "     / ____/___ _(_)_______   |/  /_  __ \\    version "
+                      << FAIRMQ_GIT_VERSION << endl
+                      << "    / /_  / __ `/ / ___/__  /|_/ /_  / / /    build " << FAIRMQ_BUILD_TYPE
+                      << endl
+                      << "   / __/ / /_/ / / /    _  /  / / / /_/ /     " << FAIRMQ_REPO_URL << endl
+                      << R"(  /_/    \__,_/_/_/     /_/  /_/  \___\_\     )" << FAIRMQ_LICENSE
+                      << "  © " << FAIRMQ_COPYRIGHT << endl;
         }
     }
 

fairmq/EventManager.cxx

@@ -0,0 +1,20 @@
+/********************************************************************************
+ *   Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH     *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+#include "EventManager.h"
+
+#include <string>
+#include <typeindex>
+
+template std::shared_ptr<
+    fair::mq::EventManager::Signal<fair::mq::PropertyChangeAsString, std::string>>
+    fair::mq::EventManager::GetSignal<fair::mq::PropertyChangeAsString, std::string>(
+        const std::pair<std::type_index, std::type_index>& key) const;
+
+template void fair::mq::EventManager::Subscribe<fair::mq::PropertyChangeAsString, std::string>(
+    const std::string& subscriber,
+    std::function<void(typename fair::mq::PropertyChangeAsString::KeyType, std::string)>);

fairmq/EventManager.h

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2014-2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2014-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -57,27 +57,8 @@ class EventManager
     template<typename E, typename ...Args>
     using Signal = boost::signals2::signal<void(typename E::KeyType, Args...)>;
 
-    template<typename E, typename ...Args>
-    auto Subscribe(const std::string& subscriber, std::function<void(typename E::KeyType, Args...)> callback) -> void
-    {
-        const std::type_index event_type_index{typeid(E)};
-        const std::type_index callback_type_index{typeid(std::function<void(typename E::KeyType, Args...)>)};
-        const auto signalsKey = std::make_pair(event_type_index, callback_type_index);
-        const auto connectionsKey = std::make_pair(subscriber, signalsKey);
-
-        const auto connection = GetSignal<E, Args...>(signalsKey)->connect(callback);
-
-        {
-            std::lock_guard<std::mutex> lock{fMutex};
-
-            if (fConnections.find(connectionsKey) != fConnections.end())
-            {
-                fConnections.at(connectionsKey).disconnect();
-                fConnections.erase(connectionsKey);
-            }
-            fConnections.insert({connectionsKey, connection});
-        }
-    }
+    template<typename E, typename... Args>
+    auto Subscribe(const std::string& subscriber, std::function<void(typename E::KeyType, Args...)> callback) -> void;
 
     template<typename E, typename ...Args>
     auto Unsubscribe(const std::string& subscriber) -> void
@@ -119,21 +100,58 @@ class EventManager
     mutable std::mutex fMutex;
 
     template<typename E, typename ...Args>
-    auto GetSignal(const SignalsKey& key) const -> std::shared_ptr<Signal<E, Args...>>
+    auto GetSignal(const SignalsKey& key) const -> std::shared_ptr<Signal<E, Args...>>;
+}; /* class EventManager */
+
+struct PropertyChangeAsString : Event<std::string> {};
+
+template<typename E, typename... Args>
+auto EventManager::GetSignal(const SignalsKey& key) const -> std::shared_ptr<Signal<E, Args...>>
+{
+    std::lock_guard<std::mutex> lock{fMutex};
+
+    if (fSignals.find(key) == fSignals.end()) {
+        // wrapper is needed because boost::signals2::signal is neither copyable nor movable
+        // and I don't know how else to insert it into the map
+        auto signal = std::make_shared<Signal<E, Args...>>();
+        fSignals.insert(std::make_pair(key, signal));
+    }
+
+    return boost::any_cast<std::shared_ptr<Signal<E, Args...>>>(fSignals.at(key));
+}
+
+template<typename E, typename... Args>
+auto EventManager::Subscribe(const std::string& subscriber,
+                             std::function<void(typename E::KeyType, Args...)> callback) -> void
+{
+    const std::type_index event_type_index{typeid(E)};
+    const std::type_index callback_type_index{
+        typeid(std::function<void(typename E::KeyType, Args...)>)};
+    const auto signalsKey = std::make_pair(event_type_index, callback_type_index);
+    const auto connectionsKey = std::make_pair(subscriber, signalsKey);
+
+    const auto connection = GetSignal<E, Args...>(signalsKey)->connect(callback);
+
     {
         std::lock_guard<std::mutex> lock{fMutex};
 
-        if (fSignals.find(key) == fSignals.end())
-        {
-            // wrapper is needed because boost::signals2::signal is neither copyable nor movable
-            // and I don't know how else to insert it into the map
-            auto signal = std::make_shared<Signal<E, Args...>>();
-            fSignals.insert(std::make_pair(key, signal));
+        if (fConnections.find(connectionsKey) != fConnections.end()) {
+            fConnections.at(connectionsKey).disconnect();
+            fConnections.erase(connectionsKey);
         }
-
-        return boost::any_cast<std::shared_ptr<Signal<E, Args...>>>(fSignals.at(key));
+        fConnections.insert({connectionsKey, connection});
     }
-}; /* class EventManager */
+}
+
+extern template std::shared_ptr<
+    fair::mq::EventManager::Signal<fair::mq::PropertyChangeAsString, std::string>>
+    fair::mq::EventManager::GetSignal<fair::mq::PropertyChangeAsString, std::string>(
+        const std::pair<std::type_index, std::type_index>& key) const;
+
+extern template void
+    fair::mq::EventManager::Subscribe<fair::mq::PropertyChangeAsString, std::string>(
+        const std::string& subscriber,
+        std::function<void(typename fair::mq::PropertyChangeAsString::KeyType, std::string)>);
 
 } // namespace fair::mq
 

fairmq/MemoryResources.h

@@ -17,7 +17,7 @@
 
 #include <boost/container/container_fwd.hpp>
 #include <boost/container/flat_map.hpp>
-#include <boost/container/pmr/memory_resource.hpp>
+#include <memory_resource>
 #include <cstring>
 #include <fairmq/Message.h>
 #include <stdexcept>
@@ -27,7 +27,7 @@ namespace fair::mq {
 
 class TransportFactory;
 using byte = unsigned char;
-namespace pmr = boost::container::pmr;
+namespace pmr = std::pmr;
 
 /// All FairMQ related memory resources need to inherit from this interface
 /// class for the

fairmq/Message.h

@@ -10,7 +10,7 @@
 #define FAIR_MQ_MESSAGE_H
 
 #include <cstddef>   // for size_t
-#include <fairmq/Transports.h>
+#include <fairmq/TransportEnum.h>
 #include <memory>   // unique_ptr
 #include <stdexcept>
 

fairmq/Parts.h

@@ -87,7 +87,7 @@ struct Parts
     const_iterator end() const noexcept { return fParts.end(); }
     const_iterator cend() const noexcept { return fParts.cend(); }
 
-    container fParts{};
+    container fParts;
 };
 
 }   // namespace fair::mq

fairmq/PluginManager.cxx

@@ -32,12 +32,9 @@ const std::string fair::mq::PluginManager::fgkLibPrefixAlt = "FairMQPlugin_";
 std::vector<boost::dll::shared_library> fair::mq::PluginManager::fgDLLKeepAlive =
     std::vector<boost::dll::shared_library>();
 
-fair::mq::PluginManager::PluginManager()
-    : fPluginServices()
-{}
+fair::mq::PluginManager::PluginManager() {}
 
 fair::mq::PluginManager::PluginManager(const vector<string>& args)
-    : fPluginServices()
 {
     // Parse command line options
     auto options = ProgramOptions();

fairmq/PluginServices.cxx

@@ -17,7 +17,9 @@ auto PluginServices::ChangeDeviceState(const string& controller, const DeviceSta
 {
     lock_guard<mutex> lock{fDeviceControllerMutex};
 
-    if (!fDeviceController) fDeviceController = controller;
+    if (!fDeviceController) {
+        fDeviceController = controller;
+    }
 
     if (fDeviceController == controller) {
         return fDevice.ChangeState(next);

fairmq/ProgOptions.cxx

@@ -189,7 +189,7 @@ vector<string> ProgOptions::GetPropertyKeys() const
     vector<string> keys;
 
     for (const auto& it : fVarMap) {
-        keys.push_back(it.first.c_str());
+        keys.emplace_back(it.first.c_str());
     }
 
     return keys;
@@ -448,3 +448,6 @@ void ProgOptions::PrintOptionsRaw() const
 }
 
 } // namespace fair::mq
+
+template void fair::mq::ProgOptions::SetProperty<std::string>(const std::string& key, std::string val);
+template void fair::mq::ProgOptions::SetProperty<int>(const std::string& key, int val);

fairmq/ProgOptions.h

@@ -129,17 +129,7 @@ class ProgOptions
     /// @param key
     /// @param val
     template<typename T>
-    void SetProperty(const std::string& key, T val)
-    {
-        std::unique_lock<std::mutex> lock(fMtx);
-
-        SetVarMapValue<typename std::decay<T>::type>(key, val);
-
-        lock.unlock();
-
-        fEvents.Emit<fair::mq::PropertyChange, typename std::decay<T>::type>(key, val);
-        fEvents.Emit<fair::mq::PropertyChangeAsString, std::string>(key, GetPropertyAsString(key));
-    }
+    void SetProperty(const std::string& key, T val);
 
     /// @brief Updates an existing config property (or fails if it doesn't exist)
     /// @param key
@@ -275,5 +265,20 @@ class ProgOptions
 };
 
 } // namespace fair::mq
+template <typename T>
+void fair::mq::ProgOptions::SetProperty(const std::string& key, T val)
+{
+    std::unique_lock<std::mutex> lock(fMtx);
+
+    SetVarMapValue<typename std::decay<T>::type>(key, val);
+
+    lock.unlock();
+
+    fEvents.Emit<fair::mq::PropertyChange, typename std::decay<T>::type>(key, val);
+    fEvents.Emit<fair::mq::PropertyChangeAsString, std::string>(key, GetPropertyAsString(key));
+}
+
+extern template void fair::mq::ProgOptions::SetProperty<int>(const std::string& key, int val);
+extern template void fair::mq::ProgOptions::SetProperty<std::string>(const std::string& key, std::string val);
 
 #endif /* FAIR_MQ_PROGOPTIONS_H */

fairmq/Properties.h

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2014-2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2014-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -29,7 +29,6 @@ using Property = boost::any;
 using Properties = std::map<std::string, Property>;
 
 struct PropertyChange : Event<std::string> {};
-struct PropertyChangeAsString : Event<std::string> {};
 
 class PropertyHelper
 {

fairmq/Socket.h

@@ -52,8 +52,8 @@ struct Socket
 
     virtual int64_t Send(MessagePtr& msg, int timeout = -1) = 0;
     virtual int64_t Receive(MessagePtr& msg, int timeout = -1) = 0;
-    virtual int64_t Send(std::vector<std::unique_ptr<Message>>& msgVec, int timeout = -1) = 0;
-    virtual int64_t Receive(std::vector<std::unique_ptr<Message>>& msgVec, int timeout = -1) = 0;
+    virtual int64_t Send(Parts::container& msgVec, int timeout = -1) = 0;
+    virtual int64_t Receive(Parts::container & msgVec, int timeout = -1) = 0;
     virtual int64_t Send(Parts& parts, int timeout = -1) { return Send(parts.fParts, timeout); }
     virtual int64_t Receive(Parts& parts, int timeout = -1) { return Receive(parts.fParts, timeout); }
 

fairmq/SuboptParser.cxx

@@ -79,7 +79,7 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
 
     ptree channelsArray;
 
-    for (auto token : channelConfig) {
+    for (const auto& token : channelConfig) {
         string channelName;
         ptree channelProperties;
 

fairmq/TransportEnum.h

@@ -0,0 +1,22 @@
+/********************************************************************************
+ * Copyright (C) 2014-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_TRANSPORTENUMS_H
+#define FAIR_MQ_TRANSPORTENUMS_H
+
+namespace fair::mq {
+
+enum class Transport {
+    DEFAULT,
+    ZMQ,
+    SHM
+};
+
+}
+
+#endif // FAIR_MQ_TRANSPORTENUMS_H

fairmq/TransportFactory.h

@@ -14,7 +14,7 @@
 #include <fairmq/Message.h>
 #include <fairmq/Poller.h>
 #include <fairmq/Socket.h>
-#include <fairmq/Transports.h>
+#include <fairmq/TransportEnum.h>
 #include <fairmq/UnmanagedRegion.h>
 #include <memory>   // shared_ptr
 #include <stdexcept>

fairmq/Transports.h

@@ -10,6 +10,7 @@
 #define FAIR_MQ_TRANSPORTS_H
 
 #include <fairmq/tools/Strings.h>
+#include <fairmq/TransportEnum.h>
 #include <memory>
 #include <ostream>
 #include <stdexcept>
@@ -18,13 +19,6 @@
 
 namespace fair::mq {
 
-enum class Transport
-{
-    DEFAULT,
-    ZMQ,
-    SHM
-};
-
 struct TransportError : std::runtime_error
 {
     using std::runtime_error::runtime_error;

fairmq/UnmanagedRegion.h

@@ -9,7 +9,7 @@
 #ifndef FAIR_MQ_UNMANAGEDREGION_H
 #define FAIR_MQ_UNMANAGEDREGION_H
 
-#include <fairmq/Transports.h>
+#include <fairmq/TransportEnum.h>
 
 #include <cstddef>   // size_t
 #include <cstdint>   // uint32_t
@@ -135,7 +135,7 @@ struct RegionConfig
     int64_t userFlags = 0; /// custom flags that have no effect on the transport, but can be retrieved from the region by the user
     uint64_t size = 0; /// region size
     uint64_t rcSegmentSize = 100000000; /// size of the segment that stores reference counts when "soft"-copying the messages
-    std::string path = ""; /// file path, if the region is backed by a file
+    std::string path;                   /// file path, if the region is backed by a file
     std::optional<uint16_t> id = std::nullopt; /// region id
     uint32_t linger = 100; /// delay in ms before region destruction to collect outstanding events
 };

fairmq/Version.h.in

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2018-2022 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2018-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -19,7 +19,7 @@
 #define FAIRMQ_GIT_DATE "@PROJECT_GIT_DATE@"
 #define FAIRMQ_REPO_URL "https://github.com/FairRootGroup/FairMQ"
 #define FAIRMQ_LICENSE "LGPL-3.0"
-#define FAIRMQ_COPYRIGHT "2012-2023 GSI"
+#define FAIRMQ_COPYRIGHT "2012-2025 GSI"
 #define FAIRMQ_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
 
 #endif // FAIR_MQ_VERSION_H

fairmq/plugins/control/Control.cxx

@@ -65,13 +65,17 @@ Control::Control(const string& name, Plugin::Version version, const string& main
     });
 
     try {
-        TakeDeviceControl();
-
         auto control = GetProperty<string>("control");
 
+        if (control != "none") {
+            TakeDeviceControl();
+        }
+
         if (control == "static") {
             LOG(debug) << "Running builtin controller: static";
             fControllerThread = thread(&Control::StaticMode, this);
+        } else if (control == "none") {
+            LOG(debug) << "Builtin controller: disabled";
         } else if (control == "gui") {
             LOG(debug) << "Running builtin controller: gui";
             fControllerThread = thread(&Control::GUIMode, this);
@@ -142,7 +146,7 @@ auto ControlPluginProgramOptions() -> Plugin::ProgOptions
     namespace po = boost::program_options;
     auto pluginOptions = po::options_description{"Control (builtin) Plugin"};
     pluginOptions.add_options()
-        ("control",       po::value<string>()->default_value("dynamic"), "Control mode, 'static' or 'dynamic' (aliases for dynamic are external and interactive)")
+        ("control",       po::value<string>()->default_value("dynamic"), "Control mode, 'static' or 'dynamic' (aliases for dynamic are external and interactive), 'none', 'gui'")
         ("catch-signals", po::value<int   >()->default_value(1),             "Enable signal handling (1/0).");
     return pluginOptions;
 }
@@ -271,11 +275,11 @@ auto Control::InteractiveMode() -> void
 try {
     RunStartupSequence();
 
-    if(!fDeviceShutdownRequested) {
+    if (!fDeviceShutdownRequested) {
         RunREPL();
     }
 
-    if(!fDeviceShutdownRequested) {
+    if (!fDeviceShutdownRequested) {
         RunShutdownSequence();
     }
 } catch (PluginServices::DeviceControlError& e) {
@@ -404,7 +408,7 @@ try {
     // or for device shutdown request (Ctrl-C)
     fStateQueue.WaitForNextOrCustom([this]{ return fDeviceShutdownRequested.load(); });
 
-    if(!fDeviceShutdownRequested) {
+    if (!fDeviceShutdownRequested) {
         RunShutdownSequence();
     }
 } catch (PluginServices::DeviceControlError& e) {
@@ -421,7 +425,7 @@ try {
     // Wait for device shutdown request (Ctrl-C)
     fStateQueue.WaitForCustom([this]{ return fDeviceShutdownRequested.load(); });
 
-    if(!fDeviceShutdownRequested) {
+    if (!fDeviceShutdownRequested) {
         RunShutdownSequence();
     }
 } catch (PluginServices::DeviceControlError& e) {

fairmq/shmem/Common.h

@@ -13,7 +13,8 @@
 #include <functional> // std::equal_to
 
 #include <boost/functional/hash.hpp>
-#include <boost/interprocess/allocators/adaptive_pool.hpp>
+// #include <boost/interprocess/allocators/adaptive_pool.hpp>
+#include <boost/interprocess/allocators/node_allocator.hpp>
 #include <boost/interprocess/allocators/allocator.hpp>
 #include <boost/interprocess/containers/map.hpp>
 #include <boost/interprocess/containers/string.hpp>
@@ -69,9 +70,10 @@ struct RefCount
 static constexpr size_t numNodesPerBlock = 4096;
 // Maximum number of totally free blocks that the adaptive node pool will hold.
 // The rest of the totally free blocks will be deallocated with the segment manager.
-static constexpr size_t maxFreeBlocks = 2;
+// static constexpr size_t maxFreeBlocks = 2;
 
-using RefCountPool = boost::interprocess::adaptive_pool<RefCount, boost::interprocess::managed_shared_memory::segment_manager, numNodesPerBlock, maxFreeBlocks>;
+using RefCountPool = boost::interprocess::node_allocator<RefCount, boost::interprocess::managed_shared_memory::segment_manager, numNodesPerBlock>;
+// using RefCountPool = boost::interprocess::adaptive_pool<RefCount, boost::interprocess::managed_shared_memory::segment_manager, numNodesPerBlock, maxFreeBlocks>;
 
 using SegmentManager = boost::interprocess::managed_shared_memory::segment_manager;
 using VoidAlloc      = boost::interprocess::allocator<void, SegmentManager>;
@@ -172,23 +174,12 @@ enum class AllocationAlgorithm : int
 
 struct RegionInfo
 {
-    static constexpr uint64_t DefaultRcSegmentSize = 10000000;
-
     RegionInfo(const char* path, int flags, uint64_t userFlags, uint64_t size, uint64_t rcSegmentSize, const VoidAlloc& alloc)
         : fPath(path, alloc)
         , fCreationFlags(flags)
         , fUserFlags(userFlags)
         , fSize(size)
         , fRCSegmentSize(rcSegmentSize)
-        , fDestroyed(false)
-    {}
-
-    RegionInfo(const VoidAlloc& alloc)
-        : RegionInfo("", 0, 0, 0, DefaultRcSegmentSize, alloc)
-    {}
-
-    RegionInfo(const char* path, int flags, uint64_t userFlags, uint64_t size, const VoidAlloc& alloc)
-        : RegionInfo(path, flags, userFlags, size, DefaultRcSegmentSize, alloc)
     {}
 
     Str fPath;
@@ -196,7 +187,7 @@ struct RegionInfo
     uint64_t fUserFlags;
     uint64_t fSize;
     uint64_t fRCSegmentSize;
-    bool fDestroyed;
+    bool fDestroyed{false};
 };
 
 using Uint16RegionInfoPairAlloc = boost::interprocess::allocator<std::pair<const uint16_t, RegionInfo>, SegmentManager>;
@@ -348,4 +339,13 @@ struct SegmentBufferShrink
 
 } // namespace fair::mq::shmem
 
+namespace fair::mq { class TransportFactory; }
+
+namespace fair::mq::shmem {
+// Resolve a MetaHeader (received over a side channel) to the local data pointer.
+// The caller is responsible for ensuring the backing buffer remains alive for the
+// duration of access; FairMQ provides no refcount protection for this path.
+char* GetDataAddressFromHandle(fair::mq::TransportFactory& factory, const MetaHeader& meta);
+} // namespace fair::mq::shmem
+
 #endif /* FAIR_MQ_SHMEM_COMMON_H_ */

fairmq/shmem/Manager.cxx

@@ -7,11 +7,18 @@
  ********************************************************************************/
 
 #include "Manager.h"
+#include "TransportFactory.h"
 
 // Needed to compile-firewall the <boost/process/async.hpp> header because it
 // interferes with the <asio/buffer.hpp> header. So, let's factor
 // the whole dependency to Boost.Process out of the header.
+#ifdef FAIRMQ_BOOST_PROCESS_V1_HEADER
+#include <boost/process/v1.hpp>
+namespace bp = boost::process::v1;
+#else
 #include <boost/process.hpp>
+namespace bp = boost::process;
+#endif
 #include <fairlogger/Logger.h>
 
 namespace fair::mq::shmem {
@@ -28,7 +35,7 @@ bool Manager::SpawnShmMonitor(const std::string& id)
         path.emplace(path.begin(), env.at(fairmq_path_key).to_string());
     }
 
-    auto exe(boost::process::search_path(shmmonitor_exe_name, path));
+    auto exe(bp::search_path(shmmonitor_exe_name, path));
     if (exe.empty()) {
         LOG(warn) << "could not find " << shmmonitor_exe_name << " in \"$" << fairmq_path_key
                   << ":$PATH\"";
@@ -39,10 +46,18 @@ bool Manager::SpawnShmMonitor(const std::string& id)
     bool verbose(env.count(shmmonitor_verbose_key)
                  && env.at(shmmonitor_verbose_key).to_string() == "true");
 
-    boost::process::spawn(
+    bp::spawn(
         exe, "-x", "-m", "--shmid", id, "-d", "-t", "2000", (verbose ? "--verbose" : ""), env);
 
     return true;
 }
 
+char* GetDataAddressFromHandle(fair::mq::TransportFactory& factory, const MetaHeader& meta)
+{
+    if (factory.GetType() != fair::mq::Transport::SHM) {
+        throw SharedMemoryError("GetDataAddressFromHandle called on a non-shmem transport");
+    }
+    return static_cast<TransportFactory&>(factory).GetDataAddressFromHandle(meta);
+}
+
 }   // namespace fair::mq::shmem

fairmq/shmem/Manager.h

@@ -323,7 +323,6 @@ class Manager
                 }
 
                 const uint16_t id = cfg.id.value();
-                const uint64_t rcSegmentSize = cfg.rcSegmentSize;
 
                 std::lock_guard<std::mutex> lock(fLocalRegionsMtx);
 
@@ -340,6 +339,12 @@ class Manager
                     LOG(debug) << "Unmanaged region (view) already present, promoting to controller";
                     region->BecomeController(cfg);
                 } else {
+                    // we need to update local config, if the region information already exists
+                    auto info = fShmRegions->find(id);
+                    if (info != fShmRegions->end()) {
+                        cfg.rcSegmentSize = info->second.fRCSegmentSize;
+                    }
+
                     auto res = fRegions.emplace(id, std::make_unique<UnmanagedRegion>(fShmId, size, true, cfg));
                     region = res.first->second.get();
                 }
@@ -348,7 +353,6 @@ class Manager
                 // start ack receiver only if a callback has been provided.
                 if (callback || bulkCallback) {
                     region->SetCallbacks(callback, bulkCallback);
-                    region->InitializeRefCountSegment(rcSegmentSize);
                     region->InitializeQueues();
                     region->StartAckSender();
                     region->StartAckReceiver();
@@ -386,8 +390,10 @@ class Manager
         }
 
         auto* lRegion = GetRegion(id);
-        fTlRegionCache.fRegionsTLCache.emplace_back(std::make_tuple(lRegion, id, fShmId64));
-        fTlRegionCache.fRegionsTLCacheGen = fRegionsGen;
+        if (lRegion) {
+            fTlRegionCache.fRegionsTLCache.emplace_back(lRegion, id, fShmId64);
+            fTlRegionCache.fRegionsTLCacheGen = fRegionsGen;
+        }
         return lRegion;
     }
 
@@ -401,19 +407,18 @@ class Manager
 
         try {
             RegionConfig cfg;
-            const uint64_t rcSegmentSize = cfg.rcSegmentSize;
             // get region info
             {
                 boost::interprocess::scoped_lock<boost::interprocess::interprocess_mutex> shmLock(*fShmMtx);
                 RegionInfo regionInfo = fShmRegions->at(id);
                 cfg.id = id;
                 cfg.creationFlags = regionInfo.fCreationFlags;
+                cfg.rcSegmentSize = regionInfo.fRCSegmentSize;
                 cfg.path = regionInfo.fPath.c_str();
             }
             // LOG(debug) << "Located remote region with id '" << id << "', path: '" << cfg.path << "', flags: '" << cfg.creationFlags << "'";
 
             auto r = fRegions.emplace(id, std::make_unique<UnmanagedRegion>(fShmId, 0, false, std::move(cfg)));
-            r.first->second->InitializeRefCountSegment(rcSegmentSize);
             r.first->second->InitializeQueues();
             r.first->second->StartAckSender();
             return r.first->second.get();
@@ -482,6 +487,7 @@ class Manager
                     cfg.id = info.id;
                     cfg.creationFlags = regionInfo.fCreationFlags;
                     cfg.path = regionInfo.fPath.c_str();
+                    cfg.rcSegmentSize = regionInfo.fRCSegmentSize;
                     regionCfgs.emplace(info.id, cfg);
                     // fill the ptr+size info after shmLock is released, to avoid constructing local region under it
                 } else {
@@ -503,10 +509,8 @@ class Manager
                     if (it != fRegions.end()) {
                         region = it->second.get();
                     } else {
-                        const uint64_t rcSegmentSize = cfgIt->second.rcSegmentSize;
                         auto r = fRegions.emplace(cfgIt->first, std::make_unique<UnmanagedRegion>(fShmId, 0, false, cfgIt->second));
                         region = r.first->second.get();
-                        region->InitializeRefCountSegment(rcSegmentSize);
                         region->InitializeQueues();
                         region->StartAckSender();
                     }
@@ -774,6 +778,30 @@ class Manager
 
     auto GetMetadataMsgSize() const noexcept { return fMetadataMsgSize; }
 
+    // Resolve a MetaHeader (received over a side channel) to the local data pointer.
+    // The caller is responsible for ensuring the backing buffer remains alive for the
+    // duration of access; FairMQ provides no refcount protection for this path.
+    char* GetDataAddressFromHandle(const MetaHeader& meta)
+    {
+        if (meta.fManaged) {
+            if (meta.fSize == 0) {
+                return nullptr;
+            }
+            GetSegment(meta.fSegmentId);
+            auto it = fSegments.find(meta.fSegmentId);
+            if (it == fSegments.end()) {
+                throw SharedMemoryError(tools::ToString("GetDataAddressFromHandle: cannot open segment with id ", meta.fSegmentId));
+            }
+            return ShmHeader::UserPtr(GetAddressFromHandle(meta.fHandle, meta.fSegmentId));
+        } else {
+            UnmanagedRegion* region = GetRegionFromCache(meta.fRegionId);
+            if (!region) {
+                throw SharedMemoryError(tools::ToString("GetDataAddressFromHandle: cannot get unmanaged region with id ", meta.fRegionId));
+            }
+            return reinterpret_cast<char*>(region->GetData()) + meta.fHandle;
+        }
+    }
+
     ~Manager()
     {
         fRegionsGen += 1; // signal TL cache invalidation

fairmq/shmem/Message.h

@@ -14,6 +14,7 @@
 #include "UnmanagedRegionImpl.h"
 #include <fairmq/Message.h>
 #include <fairmq/UnmanagedRegion.h>
+#include <fairmq/Transports.h>
 
 #include <fairlogger/Logger.h>
 
@@ -76,7 +77,12 @@ class Message final : public fair::mq::Message
         fManager.IncrementMsgCounter();
     }
 
-    Message(Manager& manager, UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, fair::mq::TransportFactory* factory = nullptr)
+    Message(Manager& manager,
+            UnmanagedRegionPtr& region,
+            void* data,
+            const size_t size,
+            void* hint = nullptr,
+            fair::mq::TransportFactory* factory = nullptr)
         : fair::mq::Message(factory)
         , fManager(manager)
         , fLocalPtr(static_cast<char*>(data))
@@ -161,6 +167,11 @@ class Message final : public fair::mq::Message
         }
     }
 
+    MetaHeader GetMeta() const
+    {
+        return {fSize, fHint, fHandle, fShared, fRegionId, fSegmentId, fManaged};
+    }
+
     void* GetData() const override
     {
         if (!fLocalPtr) {
@@ -251,7 +262,12 @@ class Message final : public fair::mq::Message
         if (!fRegionPtr) {
             throw TransportError(tools::ToString("Cannot get unmanaged region with id ", fRegionId));
         }
-        return fRegionPtr->GetRefCountAddressFromHandle(fShared)->Get();
+        if (fRegionPtr->fRcSegmentSize > 0) {
+            return fRegionPtr->GetRefCountAddressFromHandle(fShared)->Get();
+        } else {
+            fManager.GetSegment(fSegmentId);
+            return ShmHeader::RefCount(fManager.GetAddressFromHandle(fShared, fSegmentId));
+        }
     }
 
     void Copy(const fair::mq::Message& other) override
@@ -277,19 +293,29 @@ class Message final : public fair::mq::Message
             if (!fRegionPtr) {
                 throw TransportError(tools::ToString("Cannot get unmanaged region with id ", otherMsg.fRegionId));
             }
-            if (otherMsg.fShared < 0) {
-                // UR msg not yet shared, create the reference counting object with count 2
-                try {
-                    otherMsg.fShared = fRegionPtr->HandleFromAddress(&(fRegionPtr->MakeRefCount(2)));
-                } catch (boost::interprocess::bad_alloc& ba) {
-                    throw RefCountBadAlloc(tools::ToString(
-                        "Insufficient space in the reference count segment ",
-                        otherMsg.fRegionId,
-                        ", original exception: bad_alloc: ", 
-                        ba.what()));
+            if (fRegionPtr->fRcSegmentSize > 0) {
+                if (otherMsg.fShared < 0) {
+                    // UR msg not yet shared, create the reference counting object with count 2
+                    try {
+                        otherMsg.fShared = fRegionPtr->HandleFromAddress(&(fRegionPtr->MakeRefCount(2)));
+                    } catch (boost::interprocess::bad_alloc& ba) {
+                        throw RefCountBadAlloc(tools::ToString("Insufficient space in the reference count segment ", otherMsg.fRegionId, ", original exception: bad_alloc: ", ba.what()));
+                    }
+                } else {
+                    fRegionPtr->GetRefCountAddressFromHandle(otherMsg.fShared)->Increment();
+                }
+            } else { // if RefCount segment size is 0, store the ref count in the managed segment
+                if (otherMsg.fShared < 0) { // if UR msg is not yet shared
+                    char* ptr = fManager.Allocate(2, 0);
+                    // point the fShared in the unmanaged region message to the refCount holder
+                    otherMsg.fShared = fManager.GetHandleFromAddress(ptr, fSegmentId);
+                    // the message needs to be able to locate in which segment the refCount is stored
+                    otherMsg.fSegmentId = fSegmentId;
+                    ShmHeader::IncrementRefCount(ptr);
+                } else { // if the UR msg is already shared
+                    fManager.GetSegment(otherMsg.fSegmentId);
+                    ShmHeader::IncrementRefCount(fManager.GetAddressFromHandle(otherMsg.fShared, otherMsg.fSegmentId));
                 }
-            } else {
-                fRegionPtr->GetRefCountAddressFromHandle(otherMsg.fShared)->Increment();
             }
         }
 
@@ -357,10 +383,21 @@ class Message final : public fair::mq::Message
                     if (!fRegionPtr) {
                         throw TransportError(tools::ToString("Cannot get unmanaged region with id ", fRegionId));
                     }
-                    uint16_t refCount = fRegionPtr->GetRefCountAddressFromHandle(fShared)->Decrement();
-                    if (refCount == 1) {
-                        fRegionPtr->RemoveRefCount(*(fRegionPtr->GetRefCountAddressFromHandle(fShared)));
-                        ReleaseUnmanagedRegionBlock();
+                    if (fRegionPtr->fRcSegmentSize > 0) {
+                        uint16_t refCount = fRegionPtr->GetRefCountAddressFromHandle(fShared)->Decrement();
+                        if (refCount == 1) {
+                            fRegionPtr->RemoveRefCount(*(fRegionPtr->GetRefCountAddressFromHandle(fShared)));
+                            ReleaseUnmanagedRegionBlock();
+                        }
+                    } else { // if RefCount segment size is 0, get the ref count from the managed segment
+                        // make sure segment is initialized in this transport
+                        fManager.GetSegment(fSegmentId);
+                        // release unmanaged region block if ref count is one
+                        uint16_t refCount = ShmHeader::DecrementRefCount(fManager.GetAddressFromHandle(fShared, fSegmentId));
+                        if (refCount == 1) {
+                            fManager.Deallocate(fShared, fSegmentId);
+                            ReleaseUnmanagedRegionBlock();
+                        }
                     }
                 } else {
                     ReleaseUnmanagedRegionBlock();

fairmq/shmem/Monitor.cxx

@@ -59,12 +59,18 @@ void signalHandler(int signal)
     gSignalStatus = signal;
 }
 
-Monitor::Monitor(string shmId, bool selfDestruct, bool interactive, bool viewOnly, unsigned int timeoutInMS, unsigned int intervalInMS, bool monitor, bool cleanOnExit)
+Monitor::Monitor(string shmId,
+                 bool selfDestruct,
+                 bool interactive,
+                 bool viewOnly,
+                 unsigned int timeoutInMS,
+                 unsigned int intervalInMS,
+                 bool monitor,
+                 bool cleanOnExit)
     : fSelfDestruct(selfDestruct)
     , fInteractive(interactive)
     , fViewOnly(viewOnly)
     , fMonitor(monitor)
-    , fSeenOnce(false)
     , fCleanOnExit(cleanOnExit)
     , fTimeoutInMS(timeoutInMS)
     , fIntervalInMS(intervalInMS)
@@ -274,7 +280,9 @@ bool Monitor::PrintShm(const ShmId& shmId)
 
                 try {
                     managed_shared_memory rcCountSegment(open_read_only, MakeShmName(shmId.shmId, "rrc", id).c_str());
-                    ss << ", rcCountSegment size: " << rcCountSegment.get_size();
+                    auto size = rcCountSegment.get_size();
+                    auto free = rcCountSegment.get_free_memory();
+                    ss << ", rcCountSegment size: " << size << ", free: " << free << ", used: " << size - free;
                 } catch (bie&) {
                     ss << ", rcCountSegment: not found";
                 }

fairmq/shmem/Monitor.h

@@ -170,7 +170,7 @@ class Monitor
     bool fInteractive; // running in interactive mode
     bool fViewOnly; // view only mode
     bool fMonitor;
-    bool fSeenOnce; // true is segment has been opened successfully at least once
+    bool fSeenOnce{false};   // true is segment has been opened successfully at least once
     bool fCleanOnExit;
     unsigned int fTimeoutInMS;
     unsigned int fIntervalInMS;

fairmq/shmem/Poller.h

@@ -71,7 +71,7 @@ class Poller final : public fair::mq::Poller
         try {
             int offset = 0;
             // calculate offsets and the total size of the poll item set
-            for (std::string channel : channelList) {
+            for (const std::string& channel : channelList) {
                 fOffsetMap[channel] = offset;
                 offset += channelsMap.at(channel).size();
                 fNumItems += channelsMap.at(channel).size();
@@ -80,7 +80,7 @@ class Poller final : public fair::mq::Poller
             fItems = new zmq_pollitem_t[fNumItems];
 
             int index = 0;
-            for (std::string channel : channelList) {
+            for (const std::string& channel : channelList) {
                 for (unsigned int i = 0; i < channelsMap.at(channel).size(); ++i) {
                     index = fOffsetMap[channel] + i;
 

fairmq/shmem/Segment.h

@@ -10,6 +10,7 @@
 
 #include <fairmq/shmem/Common.h>
 #include <fairmq/shmem/Monitor.h>
+#include <fairmq/Transports.h>
 
 #include <cstdint>
 #include <string>

fairmq/shmem/Socket.h

@@ -39,18 +39,19 @@ namespace fair::mq::shmem
 class Socket final : public fair::mq::Socket
 {
   public:
-    Socket(Manager& manager, const std::string& type, const std::string& name, const std::string& id, void* context, fair::mq::TransportFactory* fac = nullptr)
+    Socket(Manager& manager,
+           const std::string& type,
+           const std::string& name,
+           const std::string& id,
+           void* context,
+           fair::mq::TransportFactory* fac = nullptr)
         : fair::mq::Socket(fac)
         , fManager(manager)
         , fId(id + "." + name + "." + type)
-        , fSocket(nullptr)
-        , fMonitorSocket(nullptr)
         , fBytesTx(0)
         , fBytesRx(0)
         , fMessagesTx(0)
         , fMessagesRx(0)
-        , fTimeout(100)
-        , fConnectedPeersCount(0)
         , fMetadataMsgSize(manager.GetMetadataMsgSize())
     {
         assert(context);
@@ -200,7 +201,7 @@ class Socket final : public fair::mq::Socket
         }
     }
 
-    int64_t Send(std::vector<MessagePtr>& msgVec, int timeout = -1) override
+    int64_t Send(Parts::container& msgVec, int timeout = -1) override
     {
         int flags = 0;
         if (timeout == 0) {
@@ -260,7 +261,7 @@ class Socket final : public fair::mq::Socket
         return static_cast<int>(TransferCode::error);
     }
 
-    int64_t Receive(std::vector<MessagePtr>& msgVec, int timeout = -1) override
+    int64_t Receive(Parts::container& msgVec, int timeout = -1) override
     {
         int flags = 0;
         if (timeout == 0) {
@@ -456,15 +457,15 @@ class Socket final : public fair::mq::Socket
   private:
     Manager& fManager;
     std::string fId;
-    void* fSocket;
-    void* fMonitorSocket;
+    void* fSocket{nullptr};
+    void* fMonitorSocket{nullptr};
     std::atomic<unsigned long> fBytesTx;
     std::atomic<unsigned long> fBytesRx;
     std::atomic<unsigned long> fMessagesTx;
     std::atomic<unsigned long> fMessagesRx;
 
-    int fTimeout;
-    mutable unsigned long fConnectedPeersCount;
+    int fTimeout{100};
+    mutable unsigned long fConnectedPeersCount{0};
     std::size_t fMetadataMsgSize;
 };
 

fairmq/shmem/TransportFactory.h

@@ -118,7 +118,10 @@ class TransportFactory final : public fair::mq::TransportFactory
         return std::make_unique<Message>(*fManager, data, size, ffn, hint, this);
     }
 
-    MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, size_t size, void* hint = 0) override
+    MessagePtr CreateMessage(UnmanagedRegionPtr& region,
+                             void* data,
+                             size_t size,
+                             void* hint = nullptr) override
     {
         return std::make_unique<Message>(*fManager, region, data, size, hint, this);
     }
@@ -198,6 +201,8 @@ class TransportFactory final : public fair::mq::TransportFactory
     void Resume() override { fManager->Resume(); }
     void Reset() override { fManager->Reset(); }
 
+    char* GetDataAddressFromHandle(const MetaHeader& meta) { return fManager->GetDataAddressFromHandle(meta); }
+
     ~TransportFactory() override
     {
         LOG(debug) << "Destroying Shared Memory transport...";

fairmq/shmem/UnmanagedRegion.h

@@ -13,6 +13,7 @@
 #include <fairmq/shmem/Monitor.h>
 #include <fairmq/tools/Strings.h>
 #include <fairmq/UnmanagedRegion.h>
+#include <fairmq/Transports.h>
 
 #include <fairlogger/Logger.h>
 
@@ -62,9 +63,8 @@ struct UnmanagedRegion
         , fName(MakeShmName(shmId, "rg", cfg.id.value()))
         , fQueueName(MakeShmName(shmId, "rgq", cfg.id.value()))
         , fRefCountSegmentName(MakeShmName(shmId, "rrc", cfg.id.value()))
-        , fShmemObject()
         , fFile(nullptr)
-        , fFileMapping()
+        , fRcSegmentSize(cfg.rcSegmentSize)
         , fQueue(nullptr)
         , fCallback(nullptr)
         , fBulkCallback(nullptr)
@@ -100,7 +100,7 @@ struct UnmanagedRegion
             }
             fFileMapping = file_mapping(fName.c_str(), read_write);
             LOG(debug) << "UnmanagedRegion(): initialized file: " << fName;
-            fRegion = mapped_region(fFileMapping, read_write, 0, size, 0, cfg.creationFlags);
+            fRegion = mapped_region(fFileMapping, read_write, 0, size, nullptr, cfg.creationFlags);
         } else {
             try {
                 // if opening fails, create
@@ -124,7 +124,7 @@ struct UnmanagedRegion
             }
 
             try {
-                fRegion = mapped_region(fShmemObject, read_write, 0, 0, 0, cfg.creationFlags);
+                fRegion = mapped_region(fShmemObject, read_write, 0, 0, nullptr, cfg.creationFlags);
                 if (size != 0 && size != fRegion.get_size()) {
                     LOG(error) << "Created/opened region size (" << fRegion.get_size() << ") does not match configured size (" << size << ")";
                     throw TransportError(tools::ToString("Created/opened region size (", fRegion.get_size(), ") does not match configured size (", size, ")"));
@@ -146,11 +146,13 @@ struct UnmanagedRegion
             LOG(debug) << "Successfully zeroed free memory of region " << id << ".";
         }
 
+        InitializeRefCountSegment(fRcSegmentSize);
+
         if (fControlling && created) {
             Register(shmId, cfg);
         }
 
-        LOG(debug) << (created ? "Created" : "Opened") << " unmanaged shared memory region: " << fName << " (" << (fControlling ? "controller" : "viewer") << ")";
+        LOG(debug) << (created ? "Created" : "Opened") << " unmanaged shared memory region: " << fName << " (" << (fControlling ? "controller" : "viewer") << "), refCount segment size: " << fRcSegmentSize;
     }
 
     UnmanagedRegion() = delete;
@@ -189,7 +191,7 @@ struct UnmanagedRegion
 
     RefCount& MakeRefCount(uint16_t initialCount = 1)
     {
-        RefCount* refCount = fRefCountPool->allocate(1).get();
+        RefCount* refCount = fRefCountPool->allocate_one().get();
         new (refCount) RefCount(initialCount);
         return *refCount;
     }
@@ -197,7 +199,7 @@ struct UnmanagedRegion
     void RemoveRefCount(RefCount& refCount)
     {
         refCount.~RefCount();
-        fRefCountPool->deallocate(&refCount, 1);
+        fRefCountPool->deallocate_one(&refCount);
     }
 
     ~UnmanagedRegion()
@@ -264,6 +266,7 @@ struct UnmanagedRegion
     std::condition_variable fBlockSendCV;
     std::vector<RegionBlock> fBlocksToFree;
     const std::size_t fAckBunchSize = 256;
+    uint64_t fRcSegmentSize;
     std::unique_ptr<boost::interprocess::message_queue> fQueue;
     std::unique_ptr<boost::interprocess::managed_shared_memory> fRefCountSegment;
     std::unique_ptr<RefCountPool> fRefCountPool;
@@ -319,7 +322,7 @@ struct UnmanagedRegion
     void InitializeRefCountSegment(uint64_t size)
     {
         using namespace boost::interprocess;
-        if (!fRefCountSegment) {
+        if (!fRefCountSegment && size > 0) {
             fRefCountSegment = std::make_unique<managed_shared_memory>(open_or_create, fRefCountSegmentName.c_str(), size);
             LOG(trace) << "shmem: initialized ref count segment: " << fRefCountSegmentName;
             fRefCountPool = std::make_unique<RefCountPool>(fRefCountSegment->get_segment_manager());

fairmq/shmem/UnmanagedRegionImpl.h

@@ -37,8 +37,6 @@ class UnmanagedRegionImpl final : public fair::mq::UnmanagedRegion
                     fair::mq::TransportFactory* factory)
         : fair::mq::UnmanagedRegion(factory)
         , fManager(manager)
-        , fRegion(nullptr)
-        , fRegionId(0)
     {
         auto [regionPtr, regionId] = fManager.CreateRegion(size, callback, bulkCallback, std::move(cfg));
         fRegion = regionPtr;
@@ -62,8 +60,8 @@ class UnmanagedRegionImpl final : public fair::mq::UnmanagedRegion
 
   private:
     Manager& fManager;
-    shmem::UnmanagedRegion* fRegion;
-    uint16_t fRegionId;
+    shmem::UnmanagedRegion* fRegion{nullptr};
+    uint16_t fRegionId{0};
 };
 
 } // namespace fair::mq::shmem

fairmq/tools/Network.cxx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2017-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -8,12 +8,12 @@
 
 #include <fairlogger/Logger.h>
 #include <fairmq/tools/Network.h>
+#include <fairmq/tools/Strings.h>
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE   // To get defns of NI_MAXSERV and NI_MAXHOST
 #endif
 
-#include <algorithm>
 #include <array>
 #include <boost/algorithm/string.hpp>   // trim
 #include <boost/asio.hpp>
@@ -99,7 +99,7 @@ string getDefaultRouteNetworkInterface()
     string interfaceName;
 
 #ifdef __APPLE__   // MacOS
-    unique_ptr<FILE, decltype(pclose)*> file(
+    unique_ptr<FILE, int (*)(FILE*)> file(
         popen("route -n get default | grep interface | cut -d \":\" -f 2", "r"), pclose);
 #else   // Linux
     ifstream is("/proc/net/route");
@@ -128,7 +128,7 @@ string getDefaultRouteNetworkInterface()
     LOG(debug) << "could not get network interface of the default route from /proc/net/route, "
                   "going to try via 'ip route'";
 
-    unique_ptr<FILE, decltype(pclose)*> file(
+    unique_ptr<FILE, int (*)(FILE*)> file(
         popen("ip route | grep default | cut -d \" \" -f 5 | head -n 1", "r"), pclose);
 #endif
 
@@ -158,33 +158,22 @@ string getDefaultRouteNetworkInterface()
 }
 
 string getIpFromHostname(const string& hostname)
-{
+try {
     boost::asio::io_context ioc;
+    boost::asio::ip::tcp::resolver resolver(ioc);
 
-    using namespace boost::asio::ip;
-
-    try {
-        tcp::resolver resolver(ioc);
-        tcp::resolver::query query(hostname, "");
-        tcp::resolver::iterator end;
-
-        auto it = find_if(static_cast<basic_resolver_iterator<tcp>>(resolver.resolve(query)),
-                          end,
-                          [](const tcp::endpoint& ep) { return ep.address().is_v4(); });
-
-        if (it != end) {
-            stringstream ss;
-            ss << static_cast<tcp::endpoint>(*it).address();
-            return ss.str();
-        }
+    auto const result = resolver.resolve(boost::asio::ip::tcp::v4(), hostname, "");
 
+    if (result.empty()) {
         LOG(warn) << "could not find ipv4 address for hostname '" << hostname << "'";
-
-        return "";
-    } catch (exception& e) {
-        LOG(error) << "could not resolve hostname '" << hostname << "', reason: " << e.what();
         return "";
     }
+    return ToString(result.begin()->endpoint().address());
+}
+catch (std::exception const& ex)
+{
+    LOG(error) << "could not resolve hostname '" << hostname << "', reason: " << ex.what();
+    return "";
 }
 
 }   // namespace fair::mq::tools

fairmq/tools/Process.cxx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (C) 2017-2023 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
+ * Copyright (C) 2017-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
@@ -10,17 +10,26 @@
 #include <fairmq/tools/Strings.h>
 
 #include <boost/asio.hpp>
+#ifdef FAIRMQ_BOOST_PROCESS_V1_HEADER
+#include <boost/process/v1.hpp>
+#else
 #include <boost/process.hpp>
+#endif
 #include <chrono>
 #include <csignal>   // kill, signals
 #include <iostream>
+#include <mutex>
 #include <sstream>
 #include <stdexcept>
 #include <thread>
 #include <utility>
 
 using namespace std;
+#ifdef FAIRMQ_BOOST_PROCESS_V1_HEADER
+namespace bp = boost::process::v1;
+#else
 namespace bp = boost::process;
+#endif
 namespace ba = boost::asio;
 namespace bs = boost::system;
 
@@ -32,10 +41,18 @@ class LinePrinter
         , fPrefix(std::move(prefix))
     {}
 
-    // prints line with prefix on both cout (thread-safe) and output stream
+    // prints line with prefix on both cout and output stream
     void Print(const string& line)
     {
-        cout << fair::mq::tools::ToString(fPrefix, line, "\n") << flush;
+        // Serialize: the standard allows concurrent insertion on std::cout,
+        // but libstdc++ maintains the formatted-output state (e.g.
+        // ios_base::width) with plain reads and writes that constitute data
+        // races; the lock also keeps whole lines from interleaving.
+        static mutex sCoutMutex;
+        {
+            lock_guard<mutex> lock(sCoutMutex);
+            cout << fair::mq::tools::ToString(fPrefix, line, "\n") << flush;
+        }
         fOut << fPrefix << line << endl;
     }
 
@@ -64,22 +81,22 @@ execute_result execute(const string& cmd, const string& prefix, const string& in
 
     p.Print(cmd);
 
-    ba::io_service ios;
+    ba::io_context ioc;
 
     // containers for std_in
     ba::const_buffer inputBuffer(ba::buffer(input));
-    bp::async_pipe inputPipe(ios);
+    bp::async_pipe inputPipe(ioc);
     // containers for std_out
     ba::streambuf outputBuffer;
-    bp::async_pipe outputPipe(ios);
+    bp::async_pipe outputPipe(ioc);
     // containers for std_err
     ba::streambuf errorBuffer;
-    bp::async_pipe errorPipe(ios);
+    bp::async_pipe errorPipe(ioc);
 
     const string delimiter = "\n";
-    ba::steady_timer inputTimer(ios);
+    ba::steady_timer inputTimer(ioc);
     inputTimer.expires_after(std::chrono::milliseconds(1000)); // NOLINT
-    ba::steady_timer signalTimer(ios);
+    ba::steady_timer signalTimer(ioc);
     signalTimer.expires_after(std::chrono::milliseconds(2000)); // NOLINT
 
     // child process
@@ -154,7 +171,7 @@ execute_result execute(const string& cmd, const string& prefix, const string& in
     };
     ba::async_read_until(errorPipe, errorBuffer, delimiter, onStdErr);
 
-    ios.run();
+    ioc.run();
     c.wait();
 
     result.exit_code = c.exit_code();

fairmq/zeromq/Context.h

@@ -37,7 +37,6 @@ class Context
     Context(int numIoThreads)
         : fZmqCtx(zmq_ctx_new())
         , fInterrupted(false)
-        , fRegionCounter(1)
     {
         if (!fZmqCtx) {
             throw ContextError(tools::ToString("failed creating context, reason: ", zmq_strerror(errno)));
@@ -180,7 +179,7 @@ class Context
     mutable std::mutex fMtx;
     std::atomic<bool> fInterrupted;
 
-    uint16_t fRegionCounter;
+    uint16_t fRegionCounter{1};
     std::condition_variable fRegionEventsCV;
     std::vector<RegionInfo> fRegionInfos;
     std::queue<RegionInfo> fRegionEvents;

fairmq/zeromq/Message.h

@@ -107,7 +107,11 @@ class Message final : public fair::mq::Message
         }
     }
 
-    Message(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, fair::mq::TransportFactory* factory = nullptr)
+    Message(UnmanagedRegionPtr& region,
+            void* data,
+            const size_t size,
+            void* hint = nullptr,
+            fair::mq::TransportFactory* factory = nullptr)
         : fair::mq::Message(factory)
         , fMsg(std::make_unique<zmq_msg_t>())
     {

fairmq/zeromq/Poller.h

@@ -86,7 +86,7 @@ class Poller final : public fair::mq::Poller
             fItems = new zmq_pollitem_t[fNumItems];
 
             int index = 0;
-            for (std::string channel : channelList) {
+            for (const std::string& channel : channelList) {
                 for (unsigned int i = 0; i < channelsMap.at(channel).size(); ++i) {
                     index = fOffsetMap[channel] + i;
 

fairmq/zeromq/Socket.h

@@ -41,8 +41,7 @@ class Socket final : public fair::mq::Socket
         , fBytesRx(0)
         , fMessagesTx(0)
         , fMessagesRx(0)
-        , fTimeout(100)
-        , fConnectedPeersCount(0)
+
     {
         if (fSocket == nullptr) {
             LOG(error) << "Failed creating socket " << fId << ", reason: " << zmq_strerror(errno);
@@ -154,7 +153,7 @@ class Socket final : public fair::mq::Socket
         }
     }
 
-    int64_t Send(std::vector<std::unique_ptr<fair::mq::Message>>& msgVec, int timeout = -1) override
+    int64_t Send(Parts::container& msgVec, int timeout = -1) override
     {
         int flags = 0;
         if (timeout == 0) {
@@ -206,7 +205,7 @@ class Socket final : public fair::mq::Socket
         }
     }
 
-    int64_t Receive(std::vector<std::unique_ptr<fair::mq::Message>>& msgVec, int timeout = -1) override
+    int64_t Receive(Parts::container& msgVec, int timeout = -1) override
     {
         int flags = 0;
         if (timeout == 0) {
@@ -405,8 +404,8 @@ class Socket final : public fair::mq::Socket
     std::atomic<unsigned long> fMessagesTx;
     std::atomic<unsigned long> fMessagesRx;
 
-    int fTimeout;
-    mutable unsigned long fConnectedPeersCount;
+    int fTimeout{100};
+    mutable unsigned long fConnectedPeersCount{0};
 };
 
 } // namespace fair::mq::zmq

fairmq/zeromq/TransportFactory.h

@@ -73,7 +73,10 @@ class TransportFactory final : public fair::mq::TransportFactory
         return std::make_unique<Message>(data, size, ffn, hint, this);
     }
 
-    MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, size_t size, void* hint = 0) override
+    MessagePtr CreateMessage(UnmanagedRegionPtr& region,
+                             void* data,
+                             size_t size,
+                             void* hint = nullptr) override
     {
         return std::make_unique<Message>(region, data, size, hint, this);
     }

test/CMakeLists.txt

@@ -16,18 +16,33 @@ if(FairLogger_VERSION VERSION_LESS 1.9.0 AND FairLogger_VERSION VERSION_GREATER_
   LIST(APPEND definitions FAIR_MIN_SEVERITY=trace)
 endif()
 
+if(FAIRMQ_BOOST_PROCESS_V1_HEADER)
+  LIST(APPEND definitions FAIRMQ_BOOST_PROCESS_V1_HEADER)
+endif()
+
 if(definitions)
   set(definitions DEFINITIONS ${definitions})
 endif()
 
+set(test_environment)
 if(ENABLE_SANITIZER_LEAK)
   get_filename_component(lsan_supps "${CMAKE_CURRENT_SOURCE_DIR}/leak_sanitizer_suppressions.txt" ABSOLUTE)
-  set(environment ENVIRONMENT "LSAN_OPTIONS=set:suppressions=${lsan_supps}")
+  list(APPEND test_environment "LSAN_OPTIONS=set:suppressions=${lsan_supps}")
+endif()
+# Run the tests against an alternative runtime library directory, e.g. a
+# tsan-instrumented libstdc++. Set per test (not at the job level), because
+# such a library must only be loaded into instrumented executables.
+if(FAIRMQ_TEST_LD_LIBRARY_PATH)
+  list(APPEND test_environment "LD_LIBRARY_PATH=path_list_prepend:${FAIRMQ_TEST_LD_LIBRARY_PATH}")
+endif()
+if(test_environment)
+  set(environment ENVIRONMENT ${test_environment})
 endif()
 
 add_testhelper(runTestDevice
     SOURCES
     helper/runTestDevice.cxx
+    helper/LocaleWarmup.h
     helper/devices/TestPairLeft.h
     helper/devices/TestPairRight.h
     helper/devices/TestPollIn.h
@@ -134,6 +149,7 @@ add_testsuite(Device
              ${CMAKE_CURRENT_SOURCE_DIR}/device
              ${CMAKE_CURRENT_BINARY_DIR}
     TIMEOUT 20
+    ${definitions}
     ${environment}
 )
 
@@ -253,7 +269,7 @@ add_testsuite(Tools
     LINKS FairMQ
     INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}
              ${CMAKE_CURRENT_BINARY_DIR}
-    TIMEOUT 20
+    TIMEOUT 5
     ${environment}
 )
 

test/ci/Containerfile.fedora

@@ -1,19 +0,0 @@
-ARG VERSION=latest
-FROM fedora:${VERSION}
-ARG VERSION=latest
-LABEL org.opencontainers.image.source "https://github.com/FairRootGroup/FairMQ"
-LABEL org.opencontainers.image.description "FairMQ development environment"
-RUN dnf -y update
-# https://git.gsi.de/SDE/packages/builder
-RUN dnf -y install https://alfa-ci.gsi.de/packages/rpm/fedora-$VERSION-x86_64/fairsoft-release-dev.rpm
-RUN dnf -y install clang cli11-devel ninja-build 'dnf-command(builddep)' libasan liblsan libtsan libubsan clang-tools-extra
-RUN dnf -y builddep fairmq
-RUN dnf -y clean all
-
-# buildah build --build-arg "VERSION=36" -t "ghcr.io/fairrootgroup/fairmq-dev/fedora-36:latest" -f test/ci/Containerfile.fedora .
-# echo $GH_PAT | buildah login -u dennisklein --password-stdin ghcr.io
-# buildah push ghcr.io/fairrootgroup/fairmq-dev/fedora-36:latest
-
-# apptainer pull docker://ghcr.io/fairrootgroup/fairmq-dev/fedora-36:latest
-# echo $GH_PAT | apptainer remote login -u dennisklein --password-stdin oras://ghcr.io
-# apptainer push ./fedora-36_latest.sif oras://ghcr.io/fairrootgroup/fairmq-dev/fedora-36-sif:latest

test/ci/Containerfile.ubuntu

@@ -1,36 +0,0 @@
-ARG VERSION=latest
-FROM ubuntu:${VERSION}
-ARG VERSION=latest
-LABEL org.opencontainers.image.source "https://github.com/FairRootGroup/FairMQ"
-LABEL org.opencontainers.image.description "FairMQ development environment"
-
-RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
-RUN apt-get update
-RUN apt-get -y upgrade
-RUN apt-get -y install ca-certificates patch cmake git libboost-dev libboost-log-dev libboost-system-dev libboost-regex-dev libboost-filesystem-dev libboost-container-dev libboost-thread-dev libboost-date-time-dev libboost-program-options-dev g++ libfmt-dev ninja-build wget libczmq-dev libxml2-utils libfabric-dev libfabric-bin pkg-config
-RUN apt-get -y clean
-
-RUN cd /tmp
-
-RUN git clone -b v1.19.2 --recurse-submodules https://github.com/FairRootGroup/asio
-RUN cmake -GNinja -S asio -B asio_build -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release
-RUN cmake --build asio_build --target install
-RUN rm -rf asio asio_build
-
-RUN git clone -b v1.0.0 https://github.com/FairRootGroup/FairCMakeModules
-RUN cmake -GNinja -S FairCMakeModules -B FairCMakeModules_build -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release
-RUN cmake --build FairCMakeModules_build --target install
-RUN rm -rf FairCMakeModules FairCMakeModules_build
-
-RUN git clone -b v1.11.0 https://github.com/FairRootGroup/FairLogger
-RUN cmake -GNinja -S FairLogger -B FairLogger_build -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release -DUSE_EXTERNAL_FMT=ON
-RUN cmake --build FairLogger_build --target install
-RUN rm -rf FairLogger FairLogger_build
-
-# buildah build --build-arg "VERSION=22.04" -t "ghcr.io/fairrootgroup/fairmq-dev/ubuntu-22.04:latest" -f test/ci/Containerfile.ubuntu .
-# echo $GH_PAT | buildah login -u dennisklein --password-stdin ghcr.io
-# buildah push ghcr.io/fairrootgroup/fairmq-dev/ubuntu-22.04:latest
-
-# apptainer pull docker://ghcr.io/fairrootgroup/fairmq-dev/ubuntu-22.04:latest
-# echo $GH_PAT | apptainer remote login -u dennisklein --password-stdin oras://ghcr.io
-# apptainer push ./ubuntu-22.04_latest.sif oras://ghcr.io/fairrootgroup/fairmq-dev/ubuntu-22.04-sif:latest

test/ci/slurm-submit.sh

@@ -1,42 +0,0 @@
-#! /bin/bash
-
-label="$1"
-jobsh="$2"
-
-if [ -z "$ALFACI_SLURM_CPUS" ]
-then
-	ALFACI_SLURM_CPUS=20
-fi
-CPUS_PER_JOB=$(($ALFACI_SLURM_CPUS / 2))
-if [ -z "$ALFACI_SLURM_EXTRA_OPTS" ]
-then
-	ALFACI_SLURM_EXTRA_OPTS="--hint=compute_bound"
-fi
-if [ -z "$ALFACI_SLURM_TIMEOUT" ]
-then
-	ALFACI_SLURM_TIMEOUT=30
-fi
-if [ -z "$ALFACI_SLURM_QUEUE" ]
-then
-	ALFACI_SLURM_QUEUE=main
-fi
-
-echo "*** Slurm request options :"
-echo "***   Working directory ..: $PWD"
-echo "***   Queue ..............: $ALFACI_SLURM_QUEUE"
-echo "***   CPUs ...............: $ALFACI_SLURM_CPUS"
-echo "***   Wall Time ..........: $ALFACI_SLURM_TIMEOUT min"
-echo "***   Job Name ...........: ${label}"
-echo "***   Extra Options ......: ${ALFACI_SLURM_EXTRA_OPTS}"
-echo "*** Submitting job at ....: $(date -R)"
-(
-	set -x
-	srun -p $ALFACI_SLURM_QUEUE -c $CPUS_PER_JOB -n 1 \
-		-t $ALFACI_SLURM_TIMEOUT \
-		--job-name="${label}" \
-		${ALFACI_SLURM_EXTRA_OPTS} \
-		bash "${jobsh}"
-)
-retval=$?
-echo "*** Exit Code ............: $retval"
-exit "$retval"

test/ci/spack-boost187.yaml

@@ -0,0 +1,21 @@
+spack:
+  specs:
+    - "fairlogger@2.2.0 ^fmt@:11"
+    - "boost@1.87 +container +program_options +filesystem +date_time +regex"
+    - "libzmq@4.1.4:"
+    - ninja
+    - "cmake@3.15:"
+
+  concretizer:
+    targets:
+      granularity: generic
+
+  packages:
+    all:
+      require:
+        - target=x86_64_v3
+
+  mirrors:
+    ghcr-buildcache:
+      url: oci://ghcr.io/fairrootgroup/fairmq-spack-buildcache
+      signed: false

test/ci/spack-latest.yaml

@@ -0,0 +1,21 @@
+spack:
+  specs:
+    - "fairlogger@2.2.0 ^fmt@:11"
+    - "boost@1.66: +container +program_options +filesystem +date_time +regex"
+    - "libzmq@4.1.4:"
+    - ninja
+    - "cmake@3.15:"
+
+  concretizer:
+    targets:
+      granularity: generic
+
+  packages:
+    all:
+      require:
+        - target=x86_64_v3
+
+  mirrors:
+    ghcr-buildcache:
+      url: oci://ghcr.io/fairrootgroup/fairmq-spack-buildcache
+      signed: false

test/ci/spack-tsan.yaml

@@ -0,0 +1,47 @@
+spack:
+  specs:
+    # fairlogger and boost are left uninstrumented on purpose: no tsan report
+    # has ever implicated them. Should that change, instrument them with
+    # per-node flags like libzmq below.
+    - "fairlogger@2.2.0 ^fmt@:11"
+    - "boost@1.66: +container +program_options +filesystem +date_time +regex"
+    # libzmq (and the libsodium it links) are built with ThreadSanitizer
+    # instrumentation so tsan can observe the happens-before edges that
+    # libzmq's lock-free queues establish between user and I/O threads.
+    # Flags are set per node on purpose: the propagating '==' operator could
+    # reach the gcc node (the compiler is a dependency since spack 1.0) and
+    # trigger a full compiler rebuild.
+    - "libzmq@4.1.4: cflags='-g -fno-omit-frame-pointer -fsanitize=thread'
+       cxxflags='-g -fno-omit-frame-pointer -fsanitize=thread'
+       ldflags='-fsanitize=thread'
+       ^libsodium cflags='-g -fno-omit-frame-pointer -fsanitize=thread'
+       ldflags='-fsanitize=thread'"
+    # ThreadSanitizer-instrumented libstdc++ (from test/ci/spack_repo), a
+    # drop-in runtime replacement injected per test via LD_LIBRARY_PATH (see
+    # FAIRMQ_TEST_LD_LIBRARY_PATH in test/CMakeLists.txt).
+    # Keep the major version in lockstep with the gcc used by the tsan job.
+    - "libstdcxx-tsan@15"
+    - ninja
+    # the per-test env injection uses ctest's ENVIRONMENT_MODIFICATION,
+    # which needs cmake >= 3.22
+    - "cmake@3.22:"
+
+  concretizer:
+    targets:
+      granularity: generic
+    reuse:
+      # always re-concretize libstdcxx-tsan from the recipe in
+      # test/ci/spack_repo: spec reuse would keep resurrecting previously
+      # built (and cached) variants after the recipe changed; unchanged
+      # recipes still hit the buildcache because the hash is identical
+      exclude: ["libstdcxx-tsan"]
+
+  packages:
+    all:
+      require:
+        - target=x86_64_v3
+
+  mirrors:
+    ghcr-buildcache:
+      url: oci://ghcr.io/fairrootgroup/fairmq-spack-buildcache
+      signed: false

test/ci/spack_repo/fairmq_ci/packages/libstdcxx_tsan/package.py

@@ -0,0 +1,90 @@
+import os
+import shutil
+
+from spack_repo.builtin.build_systems.generic import Package
+
+from spack.package import *
+
+
+class LibstdcxxTsan(Package):
+    """ThreadSanitizer-instrumented build of GCC's libstdc++.
+
+    GCC ships no supported way to produce a tsan-instrumented libstdc++ (and
+    spack's gcc package offers no hook into the target-library flags), so this
+    package builds only the libstdc++-v3 subtree from the GCC release tarball
+    matching the toolchain, with -fsanitize=thread. The result is a drop-in
+    runtime replacement for the compiler's own libstdc++ (same soname and
+    symbol versions) that lets tsan observe the synchronization inside the
+    C++ standard library (e.g. std::locale/std::regex lazy initialization).
+
+    Select it via LD_LIBRARY_PATH in the environment of the instrumented
+    executables only. Like any shared library built with gcc
+    -fsanitize=thread it carries unresolved __tsan_* symbols satisfied by the
+    executable's libtsan, so loading it into an uninstrumented executable
+    fails.
+
+    Recipe modeled on https://iree.dev/developers/debugging/sanitizers/.
+    """
+
+    homepage = "https://gcc.gnu.org/onlinedocs/libstdc++/"
+    url = "https://ftp.gnu.org/gnu/gcc/gcc-15.2.0/gcc-15.2.0.tar.xz"
+
+    # Keep in lockstep with the gcc version used by the tsan CI job: a
+    # libstdc++ older than the compiler may lack GLIBCXX symbol versions
+    # that binaries built by that compiler reference. Checksums match the
+    # version() directives in spack's gcc package.
+    version("15.2.0", sha256="438fd996826b0c82485a29da03a72d71d6e3541a83ec702df4271f6fe025d24e")
+    version("14.3.0", sha256="e0dc77297625631ac8e50fa92fffefe899a4eb702592da5c32ef04e2293aca3a")
+
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
+    depends_on("gmake", type="build")
+
+    def install(self, spec, prefix):
+        # gthr-default.h only materializes in a configured libgcc build dir;
+        # on POSIX targets it is a verbatim copy of gthr-posix.h. Providing it
+        # up front spares building libgcc (and the in-tree compiler).
+        gthr_include = join_path(self.stage.source_path, "spack-gthr")
+        mkdirp(gthr_include)
+        copy(
+            join_path(self.stage.source_path, "libgcc", "gthr-posix.h"),
+            join_path(gthr_include, "gthr-default.h"),
+        )
+
+        flags = f"-I{gthr_include} -O2 -g -fno-omit-frame-pointer -fsanitize=thread"
+        build_dir = join_path(self.stage.source_path, "spack-build")
+        mkdirp(build_dir)
+        with working_dir(build_dir):
+            configure = Executable(
+                join_path(self.stage.source_path, "libstdc++-v3", "configure")
+            )
+            configure(
+                f"--prefix={prefix}",
+                f"--libdir={prefix.lib}",
+                "--disable-multilib",
+                "--disable-libstdcxx-pch",
+                "--enable-libstdcxx-threads=yes",
+                "--with-default-libstdcxx-abi=new",
+                f"CFLAGS={flags}",
+                f"CXXFLAGS={flags}",
+                "LDFLAGS=-fsanitize=thread",
+            )
+            make()
+            make("install")
+
+        # The runtime libraries land in the multilib os dir (lib64 on
+        # x86_64), --libdir notwithstanding (--with-toolexeclibdir only
+        # applies to cross builds); normalize to lib/ for the consumer.
+        if os.path.isdir(prefix.lib64):
+            mkdirp(prefix.lib)
+            for entry in os.listdir(prefix.lib64):
+                shutil.move(join_path(prefix.lib64, entry), join_path(prefix.lib, entry))
+            os.rmdir(prefix.lib64)
+
+        # Only the runtime library is consumed -- compilation uses the
+        # compiler's own (identical) headers. Drop the rest to keep the
+        # buildcache entry small.
+        for directory in ("include", "share"):
+            path = join_path(prefix, directory)
+            if os.path.isdir(path):
+                shutil.rmtree(path)

test/ci/spack_repo/fairmq_ci/repo.yaml

@@ -0,0 +1,3 @@
+repo:
+  namespace: fairmq_ci
+  api: v2.0

test/device/_config.cxx

@@ -27,7 +27,7 @@ class TestDevice : public Device
 {
   public:
     TestDevice(const string& transport)
-    : fDeviceThread(&Device::RunStateMachine, this)
+        : fDeviceThread(&Device::RunStateMachine, this)
     {
         SetTransport(transport);
         test::Control(*this, test::Cycle::ToRun);

test/device/_error_state.cxx

@@ -9,7 +9,11 @@
 #include "runner.h"
 
 #include <gtest/gtest.h>
+#ifdef FAIRMQ_BOOST_PROCESS_V1_HEADER
+#include <boost/process/v1.hpp>
+#else
 #include <boost/process.hpp>
+#endif
 #include <fairmq/tools/Process.h>
 #include <fairmq/tools/Unique.h>
 #include <fairmq/Device.h>

test/device/_exceptions.cxx

@@ -9,7 +9,11 @@
 #include "runner.h"
 
 #include <gtest/gtest.h>
+#ifdef FAIRMQ_BOOST_PROCESS_V1_HEADER
+#include <boost/process/v1.hpp>
+#else
 #include <boost/process.hpp>
+#endif
 #include <fairmq/tools/Process.h>
 #include <fairmq/tools/Unique.h>
 

test/device/_signals.cxx

@@ -9,7 +9,11 @@
 #include "runner.h"
 
 #include <gtest/gtest.h>
+#ifdef FAIRMQ_BOOST_PROCESS_V1_HEADER
+#include <boost/process/v1.hpp>
+#else
 #include <boost/process.hpp>
+#endif
 #include <fairmq/tools/Unique.h>
 #include <fairmq/tools/Process.h>
 

test/event_manager/_event_manager.cxx

@@ -29,13 +29,17 @@ TEST(EventManager, Basics)
     std::function<void(typename TestEvent::KeyType, int)> callback{
         [&](TestEvent::KeyType key, int newValue){
             ++call_counter;
-            if (key == "test") value = newValue;
+            if (key == "test") {
+                value = newValue;
+            }
         }
     };
     std::function<void(typename TestEvent::KeyType, string)> callback2{
         [&](TestEvent::KeyType key, string newValue){
             ++call_counter2;
-            if (key == "test") value2 = newValue;
+            if (key == "test") {
+                value2 = newValue;
+            }
         }
     };
 

test/helper/LocaleWarmup.h

@@ -0,0 +1,63 @@
+/********************************************************************************
+ *    Copyright (C) 2026 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ *                                                                              *
+ *              This software is distributed under the terms of the             *
+ *              GNU Lesser General Public Licence (LGPL) version 3,             *
+ *                  copied verbatim in the file "LICENSE"                       *
+ ********************************************************************************/
+
+#ifndef FAIR_MQ_TEST_LOCALEWARMUP_H
+#define FAIR_MQ_TEST_LOCALEWARMUP_H
+
+#include <locale>
+#include <sstream>
+
+namespace fair::mq::test {
+
+/// libstdc++'s std::ctype<char> caches narrow()/widen() results per character
+/// in plain char arrays of the global classic-locale facet -- by design with
+/// unsynchronized writes, emitted from header-inlined code (locale_facets.h).
+/// Whenever two threads exercise an uncached character concurrently (e.g. by
+/// compiling a std::regex), ThreadSanitizer rightfully reports the write as a
+/// data race. The stores are real and unsynchronized, so instrumenting
+/// libstdc++ cannot help; instead, fill the caches before any thread exists,
+/// which turns every later access into a pure read.
+inline void WarmUpLocaleCaches()
+{
+    auto const& ct = std::use_facet<std::ctype<char>>(std::locale::classic());
+    for (int c = 1; c < 256; ++c) {
+        auto const ch = static_cast<char>(c);
+        ct.narrow(ch, '\0');
+        ct.widen(ch);
+    }
+
+    // Only the range overload runs _M_narrow_init(), which sets the
+    // all-cached flag (_M_narrow_ok); the single-char loop above fills the
+    // cache without it. (widen() needs no equivalent: the single-char
+    // overload already runs _M_widen_init().)
+    char from[256];
+    char to[256];
+    for (int c = 0; c < 256; ++c) {
+        from[c] = static_cast<char>(c);
+    }
+    ct.narrow(from, from + 256, '?', to);
+
+    // num_put/num_get caches used by stream insertion/extraction
+    std::ostringstream os;
+    os << 4711 << ' ' << 3.14;
+    std::istringstream is("42 3.14");
+    int i = 0;
+    double d = 0.;
+    is >> i >> d;
+}
+
+/// For binaries that do not own main(): define a namespace-scope instance to
+/// run the warm-up during static initialization, before main().
+struct LocaleWarmup
+{
+    LocaleWarmup() { WarmUpLocaleCaches(); }
+};
+
+}   // namespace fair::mq::test
+
+#endif /* FAIR_MQ_TEST_LOCALEWARMUP_H */

test/helper/runTestDevice.cxx

@@ -6,6 +6,7 @@
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
+#include "LocaleWarmup.h"
 #include "devices/TestPairLeft.h"
 #include "devices/TestPairRight.h"
 #include "devices/TestPollIn.h"
@@ -30,6 +31,10 @@
 
 namespace bpo = boost::program_options;
 
+namespace {
+[[maybe_unused]] fair::mq::test::LocaleWarmup const gLocaleWarmup{};
+}
+
 auto addCustomOptions(bpo::options_description& options) -> void
 {
     options.add_options()

test/leak_sanitizer_suppressions.txt

@@ -1 +1,2 @@
 leak:zmq_msg_init_size
+leak:zmq::msg_t::init_size

test/memory_resources/_memory_resources.cxx

@@ -16,6 +16,7 @@
 #include <gtest/gtest.h>
 
 #include <cstring>
+#include <string>
 #include <vector>
 
 namespace
@@ -101,7 +102,7 @@ TEST(MemoryResources, allocator)
 
     size_t session{tools::UuidHash()};
     ProgOptions config;
-    config.SetProperty<string>("session", to_string(session));
+    config.SetProperty<std::string>("session", to_string(session));
 
     FactoryType factoryZMQ = TransportFactory::CreateTransportFactory("zeromq", fair::mq::tools::Uuid(), &config);
 
@@ -129,7 +130,7 @@ TEST(MemoryResources, getMessage)
 
     size_t session{tools::UuidHash()};
     ProgOptions config;
-    config.SetProperty<string>("session", to_string(session));
+    config.SetProperty<std::string>("session", to_string(session));
     config.SetProperty<bool>("shm-monitor", true);
 
     FactoryType factoryZMQ = TransportFactory::CreateTransportFactory("zeromq", fair::mq::tools::Uuid(), &config);

test/message/_message.cxx

@@ -287,8 +287,10 @@ auto ZeroCopy(bool expandedShmMetadata = false) -> void
 
 // The "zero copy" property of the Copy() method is an implementation detail and is not guaranteed.
 // Currently it holds true for the shmem (across devices) and for zeromq (within same device) transports.
-auto ZeroCopyFromUnmanaged(string const& address, bool expandedShmMetadata = false) -> void
+auto ZeroCopyFromUnmanaged(string const& address, bool expandedShmMetadata, uint64_t rcSegmentSize) -> void
 {
+    fair::Logger::SetConsoleSeverity(fair::Severity::debug);
+
     ProgOptions config1;
     ProgOptions config2;
     string session(tools::Uuid());
@@ -311,11 +313,13 @@ auto ZeroCopyFromUnmanaged(string const& address, bool expandedShmMetadata = fal
 
     const size_t msgSize{100};
     const size_t regionSize{1000000};
+    RegionConfig cfg;
+    cfg.rcSegmentSize = rcSegmentSize;
     tools::Semaphore blocker;
 
     auto region = factory1->CreateUnmanagedRegion(regionSize, [&blocker](void*, size_t, void*) {
         blocker.Signal();
-    });
+    }, cfg);
 
     {
         Channel push("Push", "push", factory1);
@@ -449,6 +453,46 @@ TEST(EmptyMessage, shmem_expanded_metadata) // NOLINT
     EmptyMessage("shmem", "ipc://test_empty_message", true);
 }
 
+// GetMeta() + GetDataAddressFromHandle() round-trip: simulates a consumer device that
+// receives message metadata over a side channel and resolves it to a local pointer.
+// Uses a second factory on the same session to exercise the open_only segment attach path.
+auto SideChannel(bool expandedShmMetadata = false) -> void
+{
+    const string session = tools::Uuid();
+
+    ProgOptions producerConfig;
+    producerConfig.SetProperty<string>("session", session);
+    producerConfig.SetProperty<size_t>("shm-segment-size", 100000000);
+    producerConfig.SetProperty<bool>("shm-monitor", true);
+    if (expandedShmMetadata) {
+        producerConfig.SetProperty<size_t>("shm-metadata-msg-size", 2048);
+    }
+    auto producerFactory(TransportFactory::CreateTransportFactory("shmem", tools::Uuid(), &producerConfig));
+
+    ProgOptions consumerConfig;
+    consumerConfig.SetProperty<string>("session", session);
+    consumerConfig.SetProperty<size_t>("shm-segment-size", 100000000);
+    consumerConfig.SetProperty<bool>("shm-monitor", true);
+    auto consumerFactory(TransportFactory::CreateTransportFactory("shmem", tools::Uuid(), &consumerConfig));
+
+    const size_t size = 2;
+    MessagePtr msg(producerFactory->CreateMessage(size));
+    memcpy(msg->GetData(), "AB", size);
+
+    // producer side: extract metadata to send over the side channel
+    const auto meta = static_cast<const shmem::Message&>(*msg).GetMeta();
+    EXPECT_EQ(meta.fSize, size);
+    EXPECT_TRUE(meta.fManaged);
+
+    // consumer side: resolve via a different factory — exercises open_only segment attach.
+    // The virtual address differs between factory mappings; only the content must match.
+    char* ptr = shmem::GetDataAddressFromHandle(*consumerFactory, meta);
+
+    ASSERT_NE(ptr, nullptr);
+    EXPECT_EQ(ptr[0], 'A');
+    EXPECT_EQ(ptr[1], 'B');
+}
+
 TEST(ZeroCopy, shmem) // NOLINT
 {
     ZeroCopy();
@@ -459,14 +503,111 @@ TEST(ZeroCopy, shmem_expanded_metadata) // NOLINT
     ZeroCopy(true);
 }
 
+// Uses a second factory on the same session to exercise the remote region lookup path.
+auto SideChannelUnmanaged() -> void
+{
+    const string session = tools::Uuid();
+
+    ProgOptions producerConfig;
+    producerConfig.SetProperty<string>("session", session);
+    producerConfig.SetProperty<size_t>("shm-segment-size", 100000000);
+    producerConfig.SetProperty<bool>("shm-monitor", true);
+    auto producerFactory(TransportFactory::CreateTransportFactory("shmem", tools::Uuid(), &producerConfig));
+
+    ProgOptions consumerConfig;
+    consumerConfig.SetProperty<string>("session", session);
+    consumerConfig.SetProperty<size_t>("shm-segment-size", 100000000);
+    consumerConfig.SetProperty<bool>("shm-monitor", true);
+    auto consumerFactory(TransportFactory::CreateTransportFactory("shmem", tools::Uuid(), &consumerConfig));
+
+    const size_t regionSize = 1000000;
+    tools::Semaphore blocker;
+    auto region = producerFactory->CreateUnmanagedRegion(regionSize, [&blocker](void*, size_t, void*) {
+        blocker.Signal();
+    });
+
+    const size_t size = 2;
+    auto msg(producerFactory->CreateMessage(region, static_cast<char*>(region->GetData()), size, nullptr));
+    memcpy(msg->GetData(), "AB", size);
+
+    const auto meta = static_cast<const shmem::Message&>(*msg).GetMeta();
+    EXPECT_EQ(meta.fSize, size);
+    EXPECT_FALSE(meta.fManaged);
+
+    // consumer resolves via its own factory — exercises remote region lookup.
+    // The virtual address differs between factory mappings; only the content must match.
+    char* ptr = shmem::GetDataAddressFromHandle(*consumerFactory, meta);
+
+    ASSERT_NE(ptr, nullptr);
+    EXPECT_EQ(ptr[0], 'A');
+    EXPECT_EQ(ptr[1], 'B');
+
+    msg.reset();
+    blocker.Wait();
+}
+
+auto SideChannelErrors() -> void
+{
+    ProgOptions config;
+    config.SetProperty<string>("session", tools::Uuid());
+    config.SetProperty<size_t>("shm-segment-size", 100000000);
+    config.SetProperty<bool>("shm-monitor", true);
+    auto shmFactory(TransportFactory::CreateTransportFactory("shmem", tools::Uuid(), &config));
+    auto zmqFactory(TransportFactory::CreateTransportFactory("zeromq", tools::Uuid(), &config));
+
+    // non-shmem factory must throw
+    shmem::MetaHeader meta{};
+    meta.fManaged = true;
+    EXPECT_THROW(shmem::GetDataAddressFromHandle(*zmqFactory, meta), shmem::SharedMemoryError);
+
+    // bad segment id must throw
+    meta.fSize = 1;
+    meta.fSegmentId = 999;
+    EXPECT_THROW(shmem::GetDataAddressFromHandle(*shmFactory, meta), shmem::SharedMemoryError);
+
+    // zero-size managed message must return nullptr (mirrors Message::GetData())
+    meta.fSize = 0;
+    EXPECT_EQ(shmem::GetDataAddressFromHandle(*shmFactory, meta), nullptr);
+}
+
+TEST(SideChannel, shmem) // NOLINT
+{
+    SideChannel();
+}
+
+TEST(SideChannel, shmem_expanded_metadata) // NOLINT
+{
+    SideChannel(true);
+}
+
+TEST(SideChannel, shmem_unmanaged) // NOLINT
+{
+    SideChannelUnmanaged();
+}
+
+TEST(SideChannel, errors) // NOLINT
+{
+    SideChannelErrors();
+}
+
 TEST(ZeroCopyFromUnmanaged, shmem) // NOLINT
 {
-    ZeroCopyFromUnmanaged("ipc://test_zerocopy_unmanaged");
+    ZeroCopyFromUnmanaged("ipc://test_zerocopy_unmanaged", false, 10000000);
 }
 
 TEST(ZeroCopyFromUnmanaged, shmem_expanded_metadata) // NOLINT
 {
-    ZeroCopyFromUnmanaged("ipc://test_zerocopy_unmanaged", true);
+    ZeroCopyFromUnmanaged("ipc://test_zerocopy_unmanaged_expanded", true, 10000000);
+}
+
+TEST(ZeroCopyFromUnmanaged, shmem_no_rc_segment) // NOLINT
+{
+    ZeroCopyFromUnmanaged("ipc://test_zerocopy_unmanaged_no_rc_segment", false, 0);
+}
+
+TEST(ZeroCopyFromUnmanaged, shmem_expanded_metadata_no_rc_segment) // NOLINT
+{
+    ZeroCopyFromUnmanaged("ipc://test_zerocopy_unmanaged_expanded_no_rc_segment", true, 0);
 }
 
 } // namespace

test/plugin_services/_control.cxx

@@ -156,7 +156,7 @@ TEST_F(PluginServices, SubscriptionThreadSafety)
     std::array<std::unique_ptr<std::thread>, subscribers> threads;
     auto id = 0;
     for (auto& thread : threads) {
-        thread = std::make_unique<std::thread>([&](){
+        thread = std::make_unique<std::thread>([&, id](){
             auto const subscriber = fair::mq::tools::ToString("subscriber_", id);
             for (auto i = 0; i < attempts; ++i) {
                 mServices.SubscribeToDeviceStateChange(subscriber, [](DeviceState){});

test/runner.cxx.in

@@ -10,6 +10,7 @@
 #include <TestEnvironment.h>
 
 #include <gtest/gtest.h>
+#include <helper/LocaleWarmup.h>
 
 #include <string>
 
@@ -24,6 +25,7 @@ string runTestDevice = "@RUN_TEST_DEVICE@";
 
 int main(int argc, char** argv)
 {
+    fair::mq::test::WarmUpLocaleCaches();
     ::testing::InitGoogleTest(&argc, argv);
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
     setenv("FAIRMQ_PATH", FAIRMQ_TEST_ENVIRONMENT, 0);

test/tools/_network.cxx

@@ -1,28 +1,37 @@
 /********************************************************************************
- *    Copyright (C) 2018 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2018-2025 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
  *                                                                              *
  *              This software is distributed under the terms of the             *
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
 
-#include <gtest/gtest.h>
 #include <fairmq/tools/Network.h>
-
+#include <gtest/gtest.h>
 #include <string>
 
 namespace
 {
 
-using namespace std;
-using namespace fair::mq;
-
-TEST(Tools, Network)
+TEST(Tools, NetworkDefaultIP)
 {
-    string interface = fair::mq::tools::getDefaultRouteNetworkInterface();
+    auto const interface = fair::mq::tools::getDefaultRouteNetworkInterface();
     EXPECT_NE(interface, "");
-    string interfaceIP = fair::mq::tools::getInterfaceIP(interface);
+    auto const interfaceIP = fair::mq::tools::getInterfaceIP(interface);
     EXPECT_NE(interfaceIP, "");
 }
 
+TEST(Tools, NetworkIPv4Localhost)
+{
+    auto const ip = fair::mq::tools::getIpFromHostname("localhost");
+    EXPECT_FALSE(ip.empty());
+    EXPECT_EQ(ip, "127.0.0.1");
+}
+
+TEST(Tools, NetworkInvalidHostname)
+{
+    auto const ip = fair::mq::tools::getIpFromHostname("non.existent.domain.invalid");
+    EXPECT_TRUE(ip.empty());
+}
+
 } /* namespace */