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

Move marker emission from per-iteration (inside the task fn) to a single
BENCHMARK_START/BENCHMARK_END pair bracketing the whole bench run in
setupBenchMethods. Each addMarker call is a synchronous FIFO round-trip
to the runner, so per-iteration markers scaled with iteration count
(millions for fast benches), overwhelmed the runner, and timed out the
walltime CI job — while also inflating the measured samples.

Emission is gated to walltime mode so the analysis runner sharing
setupBenchMethods is unaffected.

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

Author: not-matthias

packages/tinybench-plugin/src/shared.ts

@@ -1,4 +1,11 @@
-import { InstrumentHooks, setupCore, teardownCore } from "@codspeed/core";
+import {
+  getInstrumentMode,
+  InstrumentHooks,
+  MARKER_TYPE_BENCHMARK_END,
+  MARKER_TYPE_BENCHMARK_START,
+  setupCore,
+  teardownCore,
+} from "@codspeed/core";
 import { Bench, Fn, Task } from "tinybench";
 import { getTaskUri } from "./uri";
 
@@ -63,25 +70,47 @@ export abstract class BaseBenchRunner {
   protected abstract finalizeAsyncRun(): Task[];
   protected abstract finalizeSyncRun(): Task[];
 
+  /**
+   * Emit a single BENCHMARK_START/BENCHMARK_END marker pair bracketing the
+   * whole bench run. Each `addMarker` call is a synchronous FIFO round-trip
+   * to the runner, so marker volume must stay bounded: emitting markers per
+   * iteration previously overwhelmed the runner and timed out CI.
+   */
+  private sendRunMarkers(runStart: bigint, runEnd: bigint): void {
+    if (getInstrumentMode() !== "walltime") {
+      return;
+    }
+    InstrumentHooks.addMarker(
+      process.pid,
+      MARKER_TYPE_BENCHMARK_START,
+      runStart,
+    );
+    InstrumentHooks.addMarker(process.pid, MARKER_TYPE_BENCHMARK_END, runEnd);
+  }
+
   public setupBenchMethods(): void {
     this.bench.run = async () => {
       this.setupBenchRun();
 
+      const runStart = InstrumentHooks.currentTimestamp();
       for (const task of this.bench.tasks) {
         const uri = this.getTaskUri(task);
         await this.runTaskAsync(task, uri);
       }
+      this.sendRunMarkers(runStart, InstrumentHooks.currentTimestamp());
 
       return this.finalizeAsyncRun();
     };
 
     this.bench.runSync = () => {
       this.setupBenchRun();
 
+      const runStart = InstrumentHooks.currentTimestamp();
       for (const task of this.bench.tasks) {
         const uri = this.getTaskUri(task);
         this.runTaskSync(task, uri);
       }
+      this.sendRunMarkers(runStart, InstrumentHooks.currentTimestamp());
 
       return this.finalizeSyncRun();
     };

packages/tinybench-plugin/src/walltime.ts

@@ -1,8 +1,5 @@
 import {
   calculateQuantiles,
-  InstrumentHooks,
-  MARKER_TYPE_BENCHMARK_END,
-  MARKER_TYPE_BENCHMARK_START,
   mongoMeasurement,
   msToNs,
   msToS,
@@ -30,39 +27,29 @@ class WalltimeBenchRunner extends BaseBenchRunner {
 
   protected async runTaskAsync(task: Task, uri: string): Promise<void> {
     // Override the function under test to add a static frame
-    const markers = this.wrapTaskFunction(task, true);
+    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(async () => {
-      await task.run();
-      markers.flush();
-    }, uri);
+    await this.wrapWithInstrumentHooksAsync(() => task.run(), 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
-    const markers = this.wrapTaskFunction(task, false);
+    this.wrapTaskFunction(task, false);
 
     if (this.bench.opts.warmup) {
       task.warmupSync();
-      // warmup rounds must not be covered by benchmark markers
-      markers.reset();
     }
 
-    this.wrapWithInstrumentHooks(() => {
-      task.runSync();
-      markers.flush();
-    }, uri);
+    this.wrapWithInstrumentHooks(() => task.runSync(), uri);
 
     this.registerCodspeedBenchmarkFromTask(task);
   }
@@ -75,31 +62,24 @@ class WalltimeBenchRunner extends BaseBenchRunner {
     return this.finalizeWalltimeRun(false);
   }
 
-  private wrapTaskFunction(task: Task, isAsync: boolean): TaskMarkerTracker {
+  private wrapTaskFunction(task: Task, isAsync: boolean): void {
     const { fn } = task as unknown as { fn: Fn };
-    const markers = new TaskMarkerTracker();
 
     if (isAsync) {
       // eslint-disable-next-line no-inner-declarations
       async function __codspeed_root_frame__() {
-        const roundStart = InstrumentHooks.currentTimestamp();
         await fn();
-        markers.recordRound(roundStart);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (task as any).fn = __codspeed_root_frame__;
     } else {
       // eslint-disable-next-line no-inner-declarations
       function __codspeed_root_frame__() {
-        const roundStart = InstrumentHooks.currentTimestamp();
         fn();
-        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 {
@@ -149,50 +129,6 @@ 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(

packages/tinybench-plugin/tests/index.integ.test.ts

@@ -16,6 +16,8 @@ const mockCore = vi.hoisted(() => {
       startBenchmark: vi.fn(),
       stopBenchmark: vi.fn(),
       setExecutedBenchmark: vi.fn(),
+      currentTimestamp: vi.fn().mockReturnValue(0n),
+      addMarker: vi.fn(),
     },
     optimizeFunction: vi
       .fn()