Adding queue benchmark

Author: MaciejKaszynski

.bazelrc

@@ -90,6 +90,9 @@ build:ferrocene-coverage --remote_download_all
 # to be removed
 build:build_qnx8 --config=arm64-qnx
 
+# Benchmark configuration — optimized build with no debug symbols
+build:bench -c opt
+
 ## default is a stdout logger which looks like dlt logs
 ## uncomment below to use score::mw::log instead of the stdout logger
 # build --cxxopt=-DLC_LOG_SCORE_MW_LOG

MODULE.bazel

@@ -29,6 +29,8 @@ bazel_dep(name = "flatbuffers", version = "25.12.19")
 bazel_dep(name = "download_utils", version = "1.2.2")
 bazel_dep(name = "googletest", version = "1.17.0.bcr.2")
 
+bazel_dep(name = "google_benchmark", version = "1.9.5", dev_dependency = True)
+
 # S-CORE process rules
 
 bazel_dep(name = "score_bazel_platforms", version = "0.1.2", dev_dependency = True)

score/launch_manager/daemon/src/common/concurrency/BUILD

@@ -10,7 +10,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
-load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test")
 
 cc_library(
     name = "workerthread",
@@ -46,6 +46,15 @@ cc_library(
     ],
 )
 
+cc_binary(
+    name = "mpmc_concurrent_queue_bench",
+    srcs = ["mpmc_concurrent_queue_bench.cpp"],
+    deps = [
+        ":mpmc_concurrent_queue",
+        "@google_benchmark//:benchmark_main",
+    ],
+)
+
 cc_test(
     name = "mpmc_concurrent_queue_test",
     srcs = ["mpmc_concurrent_queue_test.cpp"],

score/launch_manager/daemon/src/common/concurrency/mpmc_concurrent_queue.hpp

@@ -273,36 +273,22 @@ class MPMCConcurrentQueue
         return score::cpp::blank{};
     }
 
-    /// @brief Helper type to align members to the cache lines.
-    /// @details Using padding rather than alignas(CacheLineSize) so that 
-    ///          ASan's fake stack doesn't cause UBSan misalignment.
-    template <class Atomic>
-    struct CacheLinePaddedAtomic : public std::atomic<Atomic>
-    {
-        static_assert(sizeof(std::atomic<Atomic>) < CacheLineSize,
-                      "atomic<Atomic> is too large to pad to one cache line");
-        using std::atomic<Atomic>::atomic;
-
-      private:
-        char _pad[CacheLineSize - sizeof(std::atomic<Atomic>)]{};
-    };
-
     /// @brief Underlying storage.
     std::array<Slot, Capacity> m_slots;
 
     /// @brief The front of the queue; claimed by consumers via fetch_add in pop.
     /// @details Aligned so that m_head and m_tail do not share a cache line.
-    CacheLinePaddedAtomic<std::size_t> m_head{0};
+    std::atomic<std::size_t> m_head{0};
 
     /// @brief The back of the queue; claimed by producers via fetch_add in push_impl.
     /// @details Aligned so that m_head and m_tail do not share a cache line.
-    CacheLinePaddedAtomic<std::size_t> m_tail{0};
+    std::atomic<std::size_t> m_tail{0};
 
     /// @brief Set to true by stop(); causes push() to return false and pop() to
     ///        return std::nullopt instead of blocking.
     /// @details Aligned on its own cache line so that the single stop() write
     ///          does not cause false sharing with m_tail updates in push_impl().
-    CacheLinePaddedAtomic<bool> m_stopped{false};
+    std::atomic<bool> m_stopped{false};
 
     /// @brief Counts items currently in the queue; consumers block on this when
     ///        the queue is empty.

score/launch_manager/daemon/src/common/concurrency/mpmc_concurrent_queue_bench.cpp

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#include "score/mw/launch_manager/common/concurrency/mpmc_concurrent_queue.hpp"
+
+#include <benchmark/benchmark.h>
+
+#include <atomic>
+#include <cstdint>
+#include <thread>
+#include <vector>
+
+using namespace score::lcm::internal;
+
+constexpr std::uint64_t g_items_per_prod = 10'000;
+
+template <std::size_t Capacity>
+static void BM_MPMC(benchmark::State& state)
+{
+    const std::int64_t n_producers = state.range(0);
+    const std::int64_t n_consumers = state.range(1);
+
+    for (auto _ : state)
+    {
+        // pause for init so allocs don't affect the results.
+        state.PauseTiming();
+
+        MPMCConcurrentQueue<std::uint64_t, Capacity> queue;
+        const std::uint64_t total = static_cast<std::uint64_t>(n_producers) * g_items_per_prod;
+
+        std::atomic<std::uint64_t> consumed{0};
+        std::atomic<bool> run{false};
+
+        std::vector<std::thread> producers;
+        producers.reserve(static_cast<std::size_t>(n_producers));
+
+        for (int prod_index = 0; prod_index < n_producers; ++prod_index)
+        {
+            producers.emplace_back([&]() {
+                while (!run.load(std::memory_order_acquire))
+                {
+                    std::this_thread::yield();
+                }
+                for (std::uint64_t i = 0; i < g_items_per_prod; ++i)
+                {
+                    while (!queue.push(i))
+                    {
+                    }
+                }
+            });
+        }
+
+        std::vector<std::thread> consumers;
+        consumers.reserve(static_cast<std::size_t>(n_consumers));
+
+        for (int cons_index = 0; cons_index < n_consumers; ++cons_index)
+        {
+            consumers.emplace_back([&]() {
+                while (!run.load(std::memory_order_acquire))
+                {
+                    std::this_thread::yield();
+                }
+                while (consumed.load(std::memory_order_relaxed) < total)
+                {
+                    if (queue.pop().has_value())
+                    {
+                        consumed.fetch_add(1, std::memory_order_relaxed);
+                    }
+                }
+            });
+        }
+
+        state.ResumeTiming();
+        run.store(true, std::memory_order_release);
+
+        for (auto& thread : producers)
+        {
+            thread.join();
+        }
+        while (consumed.load(std::memory_order_relaxed) < total)
+        {
+            std::this_thread::yield();
+        }
+        static_cast<void>(queue.stop());
+        for (auto& thread : consumers)
+        {
+            thread.join();
+        }
+
+        state.SetItemsProcessed(static_cast<int64_t>(total));
+    }
+}
+
+// use a variary of consumers and producers
+#define REGISTER_MPMC_BENCH(CAP)                                   \
+    BENCHMARK_TEMPLATE(BM_MPMC, CAP)                               \
+        ->ArgNames({"producers", "consumers"})                     \
+        ->Args({1, 1})                                             \
+        ->Args({2, 2})                                             \
+        ->Args({4, 4})                                             \
+        ->Args({4, 1})                                             \
+        ->Args({1, 4})                                             \
+        ->UseRealTime()
+
+REGISTER_MPMC_BENCH(16);
+REGISTER_MPMC_BENCH(64);
+REGISTER_MPMC_BENCH(256);
+REGISTER_MPMC_BENCH(1024);
+REGISTER_MPMC_BENCH(4096);
+
+BENCHMARK_MAIN();