feat!(google_benchmark): improve location of valgrind trapdoors

Author: GuillaumeLagrange

core/BUILD

@@ -7,7 +7,7 @@ CODSPEED_VERSION = "1.0.0"
 cc_library(
     name = "codspeed",
     srcs = glob(["src/**/*.cpp"] + ["src/**/*.h"] + ["src/**/*.hpp"]),
-    hdrs = ["include/codspeed.h"],
+    hdrs = glob(["include/**/*.h"] + ["include/**/*.hpp"]),
     includes = ["include"],
     defines = [
         "CODSPEED_VERSION=\\\"{}\\\"".format(CODSPEED_VERSION),

core/CMakeLists.txt

@@ -32,7 +32,7 @@ target_include_directories(
 # Disable valgrind compilation errors
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
     # Disable the old-style-cast warning for the specific target
-    target_compile_options(codspeed PRIVATE -Wno-old-style-cast)
+    target_compile_options(codspeed INTERFACE -Wno-old-style-cast)
 endif()
 
 execute_process(

core/src/callgrind.h core/include/callgrind.hcore/src/callgrind.h renamed to core/include/callgrind.h

@@ -20,12 +20,13 @@ inline void measurement_set_metadata() {
   CALLGRIND_DUMP_STATS_AT(metadata.c_str());
 }
 
-inline void measurement_start() {
+__attribute__((always_inline)) inline void measurement_start() {
   CALLGRIND_ZERO_STATS;
   CALLGRIND_START_INSTRUMENTATION;
 }
 
-inline void measurement_stop(const std::string &name) {
+__attribute__((always_inline)) inline void measurement_stop(
+    const std::string &name) {
   CALLGRIND_STOP_INSTRUMENTATION;
   CALLGRIND_DUMP_STATS_AT(name.c_str());
 };

core/src/measurement.hpp core/include/measurement.hppcore/src/measurement.hpp renamed to core/include/measurement.hpp

@@ -82,7 +82,6 @@ void CodSpeed::start_benchmark(const std::string &name) {
   }
 
   current_benchmark = uri;
-  measurement_start();
 }
 
 void CodSpeed::end_benchmark() {

core/src/valgrind.h core/include/valgrind.hcore/src/valgrind.h renamed to core/include/valgrind.h

@@ -183,6 +183,13 @@ BENCHMARK(BM_test)->Unit(benchmark::kMillisecond);
 
 #include "benchmark/export.h"
 
+#ifdef CODSPEED_ENABLED
+#include <codspeed.h>
+#include <measurement.hpp>
+
+#include <filesystem>
+#endif // CODSPEED_ENABLED
+
 #if defined(_MSC_VER)
 #include <intrin.h>  // for _ReadWriteBarrier
 #endif
@@ -939,6 +946,9 @@ class BENCHMARK_EXPORT BENCHMARK_INTERNAL_CACHELINE_ALIGNED State {
 
  public:
   const IterationCount max_iterations;
+#ifdef CODSPEED_INSTRUMENTATION
+  codspeed::CodSpeed *codspeed_;
+#endif
 
  private:
   bool started_;
@@ -959,7 +969,12 @@ class BENCHMARK_EXPORT BENCHMARK_INTERNAL_CACHELINE_ALIGNED State {
         const std::vector<int64_t>& ranges, int thread_i, int n_threads,
         internal::ThreadTimer* timer, internal::ThreadManager* manager,
         internal::PerfCountersMeasurement* perf_counters_measurement,
-        ProfilerManager* profiler_manager);
+        ProfilerManager* profiler_manager
+  #ifdef CODSPEED_INSTRUMENTATION
+        ,
+        codspeed::CodSpeed *codspeed = NULL
+  #endif
+        );
 
   void StartKeepRunning();
   // Implementation of KeepRunning() and KeepRunningBatch().
@@ -1049,6 +1064,11 @@ struct State::StateIterator {
   BENCHMARK_ALWAYS_INLINE
   bool operator!=(StateIterator const&) const {
     if (BENCHMARK_BUILTIN_EXPECT(cached_ != 0, true)) return true;
+#ifdef CODSPEED_INSTRUMENTATION
+    if (parent_->codspeed_ != NULL) {
+      parent_->codspeed_->end_benchmark();
+    }
+#endif
     parent_->FinishKeepRunning();
     return false;
   }
@@ -1063,6 +1083,12 @@ inline BENCHMARK_ALWAYS_INLINE State::StateIterator State::begin() {
 }
 inline BENCHMARK_ALWAYS_INLINE State::StateIterator State::end() {
   StartKeepRunning();
+#ifdef CODSPEED_INSTRUMENTATION
+  if (this->codspeed_ != NULL) {
+    this->codspeed_->start_benchmark(name_);
+    measurement_start();
+  }
+#endif
   return StateIterator();
 }
 
@@ -1439,10 +1465,6 @@ class Fixture : public internal::Benchmark {
       n) [[maybe_unused]]
 
 #ifdef CODSPEED_ENABLED
-#include <codspeed.h>
-
-#include <filesystem>
-
 #define CUR_FILE \
   codspeed::get_path_relative_to_workspace(__FILE__) + "::"
 #define NAMESPACE \

core/src/codspeed.cpp

@@ -174,10 +174,18 @@ State::State(std::string name, IterationCount max_iters,
              const std::vector<int64_t>& ranges, int thread_i, int n_threads,
              internal::ThreadTimer* timer, internal::ThreadManager* manager,
              internal::PerfCountersMeasurement* perf_counters_measurement,
-             ProfilerManager* profiler_manager)
+             ProfilerManager* profiler_manager
+#ifdef CODSPEED_INSTRUMENTATION
+             ,
+             codspeed::CodSpeed* codspeed
+#endif
+             )
     : total_iterations_(0),
       batch_leftover_(0),
       max_iterations(max_iters),
+#ifdef CODSPEED_INSTRUMENTATION
+      codspeed_(codspeed),
+#endif
       started_(false),
       finished_(false),
       skipped_(internal::NotSkipped),

google_benchmark/include/benchmark/benchmark.h

@@ -97,18 +97,19 @@ State BenchmarkInstance::RunInstrumented(
     internal::ThreadManager* manager,
     internal::PerfCountersMeasurement* perf_counters_measurement,
     ProfilerManager* profiler_manager) const {
-  State st(name_.function_name, 1, args_, 0, 1, timer, manager,
-           perf_counters_measurement, profiler_manager);
   // Do one repetition to avoid flakiness due to inconcistencies in CPU cache
   // from execution order
 
   internal::ThreadTimer warmup_timer = internal::ThreadTimer::Create();
   State warmup_state(name_.function_name, 1, args_, 0, 1, &warmup_timer,
-                     manager, perf_counters_measurement, profiler_manager);
+                     manager, perf_counters_measurement, profiler_manager,
+                     NULL);
   benchmark_.Run(warmup_state);
-  codspeed->start_benchmark(name().str());
+
+  State st(name().str(), 1, args_, 0, 1, timer, manager,
+           perf_counters_measurement, profiler_manager, codspeed);
+  ;
   benchmark_.Run(st);
-  codspeed->end_benchmark();
   return st;
 }
 #endif