Function withCodSpeed

test/BenchmarkTestCases.benchmark.mjs:526–923

(bench)

 * @returns {Promise<Bench>} modifier bench
 */
const withCodSpeed = async (bench) => {
	const codspeedRunnerMode = getCodspeedRunnerMode();

	if (codspeedRunnerMode === "disabled") {
		return bench;
	}

	const rawAdd = bench.add;
	const uriMap = getOrCreateUriMap(bench);

	const releaseClosuresAfterMeasure = codspeedRunnerMode === "memory";
	const NO_OP_FN = () => {};

	bench.add = (name, fn, options) => {
		const callingFile = getCallingFile();
		let uri = callingFile;
		if (bench.name !== undefined) {
			uri += `::${bench.name}`;
		}
		uri += `::${name}`;
		uriMap.set(name, { uri, fn, options });
		if (releaseClosuresAfterMeasure) {
			return rawAdd.bind(bench)(name, NO_OP_FN, {});
		}
		return rawAdd.bind(bench)(name, fn, options);
	};
	const rootCallingFile = getCallingFile();

	if (codspeedRunnerMode === "simulation" || codspeedRunnerMode === "memory") {
		// Memory mode counts allocations in the instrumented region. With `--no-opt`
		// (required by CodSpeed analysis mode), JIT stabilization isn't a factor,
		// so 2 warmup runs are enough to populate require.cache, webpack lazy
		// singletons, and V8 hidden classes. More warmup just bloats the heap with
		// garbage that the pre-measurement drain has to clean up, raising the
		// chance of an in-measurement GC and introducing variance across PRs that
		// would otherwise touch identical code paths.
		const warmupIterations =
			codspeedRunnerMode === "memory" ? 2 : bench.iterations - 1;

		const setupBenchRun = () => {
			setupCore();
			console.log(
				`[CodSpeed] running with @codspeed/tinybench (${codspeedRunnerMode} mode, ${warmupIterations} warmup iterations)`
			);
		};
		const finalizeBenchRun = () => {
			teardownCore();
			console.log(`[CodSpeed] Done running ${bench.tasks.length} benches.`);
			return bench.tasks;
		};

		/**
		 * @param {Fn} fn function
		 * @param {boolean} isAsync true if async function, otherwise false
		 * @returns {() => void} function wrapped in codspeed root frame
		 */
		const wrapFunctionWithFrame = (fn, isAsync) => {
			if (isAsync) {