feat: add multithread example

Author: not-matthias

examples/google_benchmark_bazel/helper.hpp

@@ -0,0 +1 @@
+../google_benchmark_cmake/helper.hpp

examples/google_benchmark_bazel/multithread_bench.hpp

@@ -0,0 +1 @@
+../google_benchmark_cmake/multithread_bench.hpp

examples/google_benchmark_cmake/helper.hpp

@@ -0,0 +1,36 @@
+#ifndef HELPER_HPP
+#define HELPER_HPP
+
+#ifdef _MSC_VER
+#define NOINLINE __declspec(noinline)
+#else
+#define NOINLINE __attribute__((noinline))
+#endif
+
+#include <benchmark/benchmark.h>
+
+#include <cstdint>
+#include <numeric>
+#include <vector>
+
+NOINLINE static uint64_t recursive_fib(int n) {
+  if (n <= 1) return n;
+  return recursive_fib(n - 1) + recursive_fib(n - 2);
+}
+
+NOINLINE static uint64_t expensive_operation() {
+  // Large memory allocation
+  std::vector<uint64_t> data(1024 * 1024, 42);  // 8 MiB allocation
+
+  // Expensive recursive computation that will dominate flamegraph
+  uint64_t fib_result = recursive_fib(30);
+
+  // More expensive work
+  uint64_t sum = std::accumulate(data.begin(), data.end(), uint64_t(0));
+  benchmark::DoNotOptimize(sum);
+  benchmark::DoNotOptimize(fib_result);
+
+  return sum + fib_result;
+}
+
+#endif  // HELPER_HPP

examples/google_benchmark_cmake/main.cpp

@@ -4,6 +4,7 @@
 
 #include "fibonacci_bench.hpp"
 #include "fixture_bench.hpp"
+#include "multithread_bench.hpp"
 #include "sleep_bench.hpp"
 #include "template_bench.hpp"
 

examples/google_benchmark_cmake/multithread_bench.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <benchmark/benchmark.h>
+
+#include <atomic>
+#include <thread>
+
+#include "helper.hpp"
+
+// Simple multithreaded benchmark: spawn thread, do work, join
+static void BM_SimpleMultithread(benchmark::State& state) {
+  for (auto _ : state) {
+    state.PauseTiming();
+    std::atomic<bool> work_start{false};
+    std::atomic<bool> work_done{false};
+
+    std::thread worker([&]() {
+      // Wait for the signal to start
+      while (!work_start.load()) {
+        std::this_thread::yield();
+      }
+
+      // Do some CPU work
+      benchmark::DoNotOptimize(expensive_operation());
+      work_done.store(true);
+    });
+    state.ResumeTiming();
+
+    // Signal the worker to start
+    work_start.store(true);
+
+    // Wait for worker to complete
+    while (!work_done.load()) {
+      std::this_thread::yield();
+    }
+
+    worker.join();
+  }
+}
+
+BENCHMARK(BM_SimpleMultithread);