fix: exclude paused sections via callgrind collection toggling

Replace the per-pause CALLGRIND_STOP/START_INSTRUMENTATION calls with
CALLGRIND_TOGGLE_COLLECT. Toggling instrumentation flushes callgrind's
simulated cache, so every benchmark measured an artificial cold-cache
warmup phase and the cache-warming repetition in RunAnalysis was wasted,
regressing 76 benchmarks. Toggling collection excludes paused sections
without touching simulator state.

Gate the toggles to explicit user PauseTiming()/ResumeTiming() calls:
TOGGLE_COLLECT is parity-based and collection starts enabled, so the
implicit StartKeepRunning()/FinishKeepRunning() bracket must not toggle
or it would invert the collection state for the whole run.

Bump instrument-hooks for the new callgrind_toggle_collect helper.

Fixes COD-2033

Author: not-matthias

core/CMakeLists.txt

@@ -15,7 +15,7 @@ include(FetchContent)
 FetchContent_Declare(
     instrument_hooks_repo
     GIT_REPOSITORY https://github.com/CodSpeedHQ/instrument-hooks
-    GIT_TAG 89fb72a076ec71c9eca6eee9bca98bada4b4dfb4
+    GIT_TAG b6c4a75ecd81462bfc4d975e13060217799cd6ef
 )
 FetchContent_MakeAvailable(instrument_hooks_repo)
 FetchContent_GetProperties(instrument_hooks_repo)

core/instrument-hooks

@@ -949,6 +949,15 @@ class BENCHMARK_EXPORT BENCHMARK_INTERNAL_CACHELINE_ALIGNED State {
 #if defined(CODSPEED_ANALYSIS) || defined(CODSPEED_WALLTIME)
   codspeed::CodSpeed* codspeed_;
 #endif
+#ifdef CODSPEED_ANALYSIS
+  // True between the implicit ResumeTiming() in StartKeepRunning() and the
+  // implicit PauseTiming() in FinishKeepRunning(). Only explicit user
+  // PauseTiming()/ResumeTiming() calls (inside the benchmark loop) may
+  // toggle callgrind collection: CALLGRIND_TOGGLE_COLLECT is parity-based,
+  // and collection starts enabled, so the implicit bracket calls must not
+  // toggle or they would invert the collection state for the whole run.
+  bool codspeed_in_benchmark_loop_;
+#endif
 #ifdef CODSPEED_WALLTIME
   uint64_t resume_timestamp_;
 #endif

google_benchmark/include/benchmark/benchmark.h

@@ -199,6 +199,9 @@ State::State(std::string name, IterationCount max_iters,
 #if defined(CODSPEED_ANALYSIS) || defined(CODSPEED_WALLTIME)
       codspeed_(codspeed),
 #endif
+#ifdef CODSPEED_ANALYSIS
+      codspeed_in_benchmark_loop_(false),
+#endif
 #ifdef CODSPEED_WALLTIME
       resume_timestamp_(0),
 #endif
@@ -273,7 +276,13 @@ void State::PauseTiming() {
   uint64_t pause_timestamp = measurement_current_timestamp();
 #endif
 #ifdef CODSPEED_ANALYSIS
-  callgrind_stop_instrumentation();
+  // Suspend callgrind cost collection for the paused section. Toggling
+  // collection (unlike stopping instrumentation) does not flush the
+  // simulated cache, so it adds no artificial cold-cache cost to the
+  // measured region.
+  if (codspeed_in_benchmark_loop_) {
+    callgrind_toggle_collect();
+  }
 #endif
 
   // Add in time accumulated so far
@@ -314,7 +323,10 @@ void State::ResumeTiming() {
   resume_timestamp_ = measurement_current_timestamp();
 #endif
 #ifdef CODSPEED_ANALYSIS
-  callgrind_start_instrumentation();
+  // Re-enable callgrind cost collection after a paused section.
+  if (codspeed_in_benchmark_loop_) {
+    callgrind_toggle_collect();
+  }
 #endif
 }
 
@@ -367,12 +379,22 @@ void State::StartKeepRunning() {
   manager_->StartStopBarrier();
   if (!skipped()) {
     ResumeTiming();
+#ifdef CODSPEED_ANALYSIS
+    // Arm collection toggling only after the implicit ResumeTiming() above,
+    // so that only explicit user pauses inside the loop toggle collection.
+    codspeed_in_benchmark_loop_ = true;
+#endif
   }
 }
 
 void State::FinishKeepRunning() {
   BM_CHECK(started_ && (!finished_ || skipped()));
   if (!skipped()) {
+#ifdef CODSPEED_ANALYSIS
+    // Disarm before the implicit PauseTiming() below so it does not toggle
+    // collection off for the rest of the process.
+    codspeed_in_benchmark_loop_ = false;
+#endif
     PauseTiming();
   }
   // Total iterations has now wrapped around past 0. Fix this.