fix(tinybench): emit a single walltime marker pair per task

Per-iteration markers made marker volume proportional to the iteration
count (millions for fast benches): every addMarker call is a synchronous
FIFO round-trip to the runner, which overwhelmed it and timed out the
walltime CI job. Buffer round timestamps in JS instead and flush one
BENCHMARK_START/BENCHMARK_END pair bracketing the measured rounds after
the run.

Also exclude warmup from markers (the wrapper previously emitted markers
during warmup rounds) and fix the sync path to use warmupSync(): the
un-awaited async warmup() never actually ran before runSync().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: not-matthias

packages/tinybench-plugin/src/walltime.ts

@@ -30,29 +30,39 @@ class WalltimeBenchRunner extends BaseBenchRunner {
 
   protected async runTaskAsync(task: Task, uri: string): Promise<void> {
     // Override the function under test to add a static frame
-    this.wrapTaskFunction(task, true);
+    const markers = this.wrapTaskFunction(task, true);
 
     // run the warmup of the task right before its actual run
     if (this.bench.opts.warmup) {
       await task.warmup();
+      // warmup rounds must not be covered by benchmark markers
+      markers.reset();
     }
 
     await mongoMeasurement.start(uri);
-    await this.wrapWithInstrumentHooksAsync(() => task.run(), uri);
+    await this.wrapWithInstrumentHooksAsync(async () => {
+      await task.run();
+      markers.flush();
+    }, uri);
     await mongoMeasurement.stop(uri);
 
     this.registerCodspeedBenchmarkFromTask(task);
   }
 
   protected runTaskSync(task: Task, uri: string): void {
     // Override the function under test to add a static frame
-    this.wrapTaskFunction(task, false);
+    const markers = this.wrapTaskFunction(task, false);
 
     if (this.bench.opts.warmup) {
-      task.warmup();
+      task.warmupSync();
+      // warmup rounds must not be covered by benchmark markers
+      markers.reset();
     }
 
-    this.wrapWithInstrumentHooks(() => task.runSync(), uri);
+    this.wrapWithInstrumentHooks(() => {
+      task.runSync();
+      markers.flush();
+    }, uri);
 
     this.registerCodspeedBenchmarkFromTask(task);
   }
@@ -65,24 +75,16 @@ class WalltimeBenchRunner extends BaseBenchRunner {
     return this.finalizeWalltimeRun(false);
   }
 
-  private wrapTaskFunction(task: Task, isAsync: boolean): void {
+  private wrapTaskFunction(task: Task, isAsync: boolean): TaskMarkerTracker {
     const { fn } = task as unknown as { fn: Fn };
-    const pid = process.pid;
-
-    // Emit per-round markers so the walltime instrument can bracket the actual
-    // benchmark body (excluding the harness) when attributing perf samples.
-    const finishRound = (roundStart: bigint): void => {
-      const roundEnd = InstrumentHooks.currentTimestamp();
-      InstrumentHooks.addMarker(pid, MARKER_TYPE_BENCHMARK_START, roundStart);
-      InstrumentHooks.addMarker(pid, MARKER_TYPE_BENCHMARK_END, roundEnd);
-    };
+    const markers = new TaskMarkerTracker();
 
     if (isAsync) {
       // eslint-disable-next-line no-inner-declarations
       async function __codspeed_root_frame__() {
         const roundStart = InstrumentHooks.currentTimestamp();
         await fn();
-        finishRound(roundStart);
+        markers.recordRound(roundStart);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (task as any).fn = __codspeed_root_frame__;
@@ -91,11 +93,13 @@ class WalltimeBenchRunner extends BaseBenchRunner {
       function __codspeed_root_frame__() {
         const roundStart = InstrumentHooks.currentTimestamp();
         fn();
-        finishRound(roundStart);
+        markers.recordRound(roundStart);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (task as any).fn = __codspeed_root_frame__;
     }
+
+    return markers;
   }
 
   private registerCodspeedBenchmarkFromTask(task: Task): void {
@@ -145,6 +149,50 @@ class WalltimeBenchRunner extends BaseBenchRunner {
   }
 }
 
+/**
+ * Buffers round timestamps in JS so a single BENCHMARK_START/BENCHMARK_END
+ * marker pair brackets all measured rounds of a task, emitted once after the
+ * run. Every `addMarker` call is a synchronous FIFO round-trip to the runner,
+ * so emitting markers per round made marker volume proportional to the
+ * iteration count and overwhelmed the runner (CI timeouts) while inflating
+ * the measured samples.
+ */
+class TaskMarkerTracker {
+  private firstRoundStart: bigint | null = null;
+  private lastRoundEnd: bigint | null = null;
+
+  recordRound(roundStart: bigint): void {
+    if (this.firstRoundStart === null) {
+      this.firstRoundStart = roundStart;
+    }
+    this.lastRoundEnd = InstrumentHooks.currentTimestamp();
+  }
+
+  /** Discard the rounds recorded so far (e.g. warmup rounds). */
+  reset(): void {
+    this.firstRoundStart = null;
+    this.lastRoundEnd = null;
+  }
+
+  /** Emit a single marker pair bracketing the recorded rounds. */
+  flush(): void {
+    if (this.firstRoundStart === null || this.lastRoundEnd === null) {
+      return;
+    }
+    InstrumentHooks.addMarker(
+      process.pid,
+      MARKER_TYPE_BENCHMARK_START,
+      this.firstRoundStart,
+    );
+    InstrumentHooks.addMarker(
+      process.pid,
+      MARKER_TYPE_BENCHMARK_END,
+      this.lastRoundEnd,
+    );
+    this.reset();
+  }
+}
+
 const TINYBENCH_WARMUP_DEFAULT = 16;
 
 function convertTinybenchResultToBenchmarkStats(