fix(testing): use correct number of rounds for b.Loop() benchmarks

Author: not-matthias

go-runner/src/results/raw_result.rs

@@ -11,8 +11,6 @@ pub struct RawResult {
     pub uri: String,
     pub pid: u32,
     pub codspeed_time_per_round_ns: Vec<u64>,
-
-    #[serde(default)]
     pub codspeed_iters_per_round: Vec<u64>,
 }
 
@@ -39,14 +37,11 @@ impl RawResult {
             .iter()
             .map(|t| *t as u128)
             .collect::<Vec<_>>();
-        let iters_per_round = if self.codspeed_iters_per_round.is_empty() {
-            vec![1; times_per_round_ns.len()]
-        } else {
-            self.codspeed_iters_per_round
-                .iter()
-                .map(|i| *i as u128)
-                .collect()
-        };
+        let iters_per_round = self
+            .codspeed_iters_per_round
+            .iter()
+            .map(|i| *i as u128)
+            .collect();
 
         WalltimeBenchmark::from_runtime_data(
             self.name,
@@ -68,13 +63,14 @@ mod tests {
     "name": "BenchmarkFibonacci20-16",
     "uri": "pkg/foo/fib_test.go::BenchmarkFibonacci20-16",
     "pid": 777767,
-    "codspeed_time_per_round_ns": [1000, 2000, 3000]
+    "codspeed_time_per_round_ns": [1000, 2000, 3000],
+    "codspeed_iters_per_round": [1, 2, 3]
 }"#;
         let result: RawResult = serde_json::from_str(json_data).unwrap();
 
         assert_eq!(result.name, "BenchmarkFibonacci20-16");
         assert_eq!(result.pid, 777767);
         assert_eq!(result.codspeed_time_per_round_ns.len(), 3);
-        assert_eq!(result.codspeed_iters_per_round.len(), 0); // Default: 1 per round
+        assert_eq!(result.codspeed_iters_per_round.len(), 3);
     }
 }

testing/testing/benchmark.go

@@ -165,6 +165,11 @@ func (b *B) StartTimer() {
 // while performing steps that you don't want to measure.
 func (b *B) StopTimer() {
 	if b.timerOn {
+		// For b.N loops: This will be called in runN which sets b.N to the number of iterations.
+		// For b.Loop() loops: loopSlowPath sets b.N to 0 to prevent b.N loops within b.Loop. However, since
+		// we're starting/stopping the timer for each iteration in the b.Loop() loop, we can use 1 as
+		// the number of iterations for this round.
+		b.codspeedItersPerRound = append(b.codspeedItersPerRound, max(int64(b.N), 1))
 		b.codspeedTimePerRoundNs = append(b.codspeedTimePerRoundNs, highPrecisionTimeSince(b.start))
 		b.duration += highPrecisionTimeSince(b.start)
 		// runtime.ReadMemStats(&memStats)
@@ -242,8 +247,6 @@ func (b *B) __codspeed_root_frame__runN(n int) {
 	b.previousN = n
 	b.previousDuration = b.duration
 
-	b.codspeedItersPerRound = append(b.codspeedItersPerRound, int64(n))
-
 	if b.loop.n > 0 && !b.loop.done && !b.failed {
 		b.Error("benchmark function returned without B.Loop() == false (break or return in loop?)")
 	}