overtake 2.0.1 → 2.0.2

package/build/cli.js

@@ -83,6 +83,7 @@ if (opts['compare-baseline']) {
     }
 }
 const files = new Set((await Promise.all(patterns.map((pattern) => Array.fromAsync(glob(pattern, { cwd: process.cwd() })).catch(() => [])))).flat());
+const allBaselineResults = {};
 for (const file of files) {
     const stats = await stat(file).catch(() => false);
     if (stats && stats.isFile()) {
@@ -95,16 +96,28 @@ for (const file of files) {
             instance = Benchmark.create(...args);
             return instance;
         };
-        await import(identifier);
+        try {
+            await import(identifier);
+        }
+        catch (e) {
+            console.error(`Error loading ${file}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
         if (instance) {
-            const reports = await instance.execute({
-                ...executeOptions,
-                [BENCHMARK_URL]: identifier,
-            });
+            let reports;
+            try {
+                reports = await instance.execute({
+                    ...executeOptions,
+                    [BENCHMARK_URL]: identifier,
+                });
+            }
+            catch (e) {
+                console.error(`Error executing ${file}: ${e instanceof Error ? e.message : String(e)}`);
+                continue;
+            }
             if (opts['save-baseline']) {
-                const baselineData = reportsToBaseline(reports);
-                await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
-                console.log(`Baseline saved to: ${opts['save-baseline']}`);
+                const bd = reportsToBaseline(reports);
+                Object.assign(allBaselineResults, bd.results);
             }
             if (baseline) {
                 printComparisonReports(reports, baseline);
@@ -133,3 +146,12 @@ for (const file of files) {
         }
     }
 }
+if (opts['save-baseline'] && Object.keys(allBaselineResults).length > 0) {
+    const baselineData = {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        results: allBaselineResults,
+    };
+    await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
+    console.log(`Baseline saved to: ${opts['save-baseline']}`);
+}

package/build/executor.js

@@ -2,7 +2,7 @@ import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
 import { createReport, computeStats, Report } from './reporter.js';
-import { cmp, assertNoClosure } from './utils.js';
+import { cmp, assertNoClosure, normalizeFunction } from './utils.js';
 import { Control, CONTROL_SLOTS, COMPLETE_VALUE, } from './types.js';
 const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
 export const createExecutor = (options) => {
@@ -10,6 +10,7 @@ export const createExecutor = (options) => {
     const benchmarkUrl = options[BENCHMARK_URL];
     const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
     const pending = [];
+    const activeWorkers = new Set();
     let running = 0;
     const schedule = async (task) => {
         running++;
@@ -33,11 +34,11 @@ export const createExecutor = (options) => {
         });
     };
     const runTask = async ({ id, setup, teardown, pre, run, post, data }) => {
-        const setupCode = setup?.toString();
-        const teardownCode = teardown?.toString();
-        const preCode = pre?.toString();
-        const runCode = run.toString();
-        const postCode = post?.toString();
+        const setupCode = setup ? normalizeFunction(setup.toString()) : undefined;
+        const teardownCode = teardown ? normalizeFunction(teardown.toString()) : undefined;
+        const preCode = pre ? normalizeFunction(pre.toString()) : undefined;
+        const runCode = normalizeFunction(run.toString());
+        const postCode = post ? normalizeFunction(post.toString()) : undefined;
         if (setupCode)
             assertNoClosure(setupCode, 'setup');
         if (teardownCode)
@@ -69,6 +70,7 @@ export const createExecutor = (options) => {
         const worker = new Worker(workerFile, {
             workerData,
         });
+        activeWorkers.add(worker);
         const control = new Int32Array(controlSAB);
         let progressIntervalId;
         if (onProgress && id) {
@@ -96,6 +98,7 @@ export const createExecutor = (options) => {
                 clearInterval(progressIntervalId);
             workerError = err instanceof Error ? err.message : String(err);
         }
+        activeWorkers.delete(worker);
         const count = control[Control.INDEX];
         const heapUsedKB = control[Control.HEAP_USED];
         const durations = new BigUint64Array(durationsSAB).slice(0, count).sort(cmp);
@@ -122,5 +125,15 @@ export const createExecutor = (options) => {
         ]);
         return Object.fromEntries(report);
     };
-    return { pushAsync, kill() { } };
+    return {
+        pushAsync,
+        kill() {
+            for (const w of activeWorkers)
+                w.terminate();
+            activeWorkers.clear();
+            for (const p of pending)
+                p.reject(new Error('Executor killed'));
+            pending.length = 0;
+        },
+    };
 };

package/build/runner.js

@@ -475,7 +475,6 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
             const durationNumber = Number(sampleDuration);
             if (!disableFiltering) {
                 const { median, iqr } = medianAndIqr(outlierWindow);
-                pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
                 const maxAllowed = median + OUTLIER_IQR_MULTIPLIER * iqr || Number.POSITIVE_INFINITY;
                 if (outlierWindow.length >= 8 && durationNumber > maxAllowed && durationNumber - median > OUTLIER_ABS_THRESHOLD) {
                     skipped++;
@@ -487,9 +486,7 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
                     continue;
                 }
             }
-            else {
-                pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
-            }
+            pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
             durations[i++] = sampleDuration;
             const deltaS = sampleDuration * WELFORD_SCALE - meanS;
             meanS += deltaS / BigInt(i);

package/build/utils.d.ts

@@ -4,4 +4,5 @@ export declare const cmp: (a: bigint | number, b: bigint | number) => number;
 export declare const max: (a: bigint, b: bigint) => bigint;
 export declare function div(a: bigint, b: bigint, decimals?: number): string;
 export declare function divs(a: bigint, b: bigint, scale: bigint): bigint;
+export declare function normalizeFunction(code: string): string;
 export declare function assertNoClosure(code: string, name: string): void;

package/build/utils.js

@@ -44,11 +44,14 @@ export const max = (a, b) => {
 export function div(a, b, decimals = 2) {
     if (b === 0n)
         throw new RangeError('Division by zero');
+    const neg = (a < 0n) !== (b < 0n);
+    const absA = a < 0n ? -a : a;
+    const absB = b < 0n ? -b : b;
     const scale = 10n ** BigInt(decimals);
-    const scaled = (a * scale) / b;
+    const scaled = (absA * scale) / absB;
     const intPart = scaled / scale;
     const fracPart = scaled % scale;
-    return `${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
+    return `${neg ? '-' : ''}${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
 }
 export function divs(a, b, scale) {
     if (b === 0n)
@@ -57,22 +60,75 @@ export function divs(a, b, scale) {
 }
 const KNOWN_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
 KNOWN_GLOBALS.add('arguments');
-function collectUnresolved(node, result) {
+let _unresolvedCtxt;
+function findIdentifierCtxt(node, name) {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            const r = findIdentifierCtxt(item, name);
+            if (r !== undefined)
+                return r;
+        }
+        return undefined;
+    }
+    const obj = node;
+    if (obj.type === 'Identifier' && obj.value === name && typeof obj.ctxt === 'number') {
+        return obj.ctxt;
+    }
+    for (const key of Object.keys(obj)) {
+        if (key === 'span')
+            continue;
+        const r = findIdentifierCtxt(obj[key], name);
+        if (r !== undefined)
+            return r;
+    }
+    return undefined;
+}
+function probeUnresolvedCtxt() {
+    if (_unresolvedCtxt !== undefined)
+        return _unresolvedCtxt;
+    try {
+        const ast = parseSync('var _ = () => __PROBE__', { syntax: 'ecmascript', target: 'esnext' });
+        _unresolvedCtxt = findIdentifierCtxt(ast, '__PROBE__') ?? 1;
+    }
+    catch {
+        _unresolvedCtxt = 1;
+    }
+    return _unresolvedCtxt;
+}
+function collectUnresolved(node, ctxt, result) {
     if (!node || typeof node !== 'object')
         return;
     if (Array.isArray(node)) {
         for (const item of node)
-            collectUnresolved(item, result);
+            collectUnresolved(item, ctxt, result);
         return;
     }
     const obj = node;
-    if (obj.type === 'Identifier' && obj.ctxt === 1 && typeof obj.value === 'string') {
+    if (obj.type === 'Identifier' && obj.ctxt === ctxt && typeof obj.value === 'string') {
         result.add(obj.value);
     }
     for (const key of Object.keys(obj)) {
         if (key === 'span')
             continue;
-        collectUnresolved(obj[key], result);
+        collectUnresolved(obj[key], ctxt, result);
+    }
+}
+export function normalizeFunction(code) {
+    try {
+        parseSync(`var __fn = ${code}`, { syntax: 'ecmascript', target: 'esnext' });
+        return code;
+    }
+    catch {
+        const normalized = code.startsWith('async ') ? `async function ${code.slice(6)}` : `function ${code}`;
+        try {
+            parseSync(`var __fn = ${normalized}`, { syntax: 'ecmascript', target: 'esnext' });
+            return normalized;
+        }
+        catch {
+            return code;
+        }
     }
 }
 export function assertNoClosure(code, name) {
@@ -83,8 +139,9 @@ export function assertNoClosure(code, name) {
     catch {
         return;
     }
+    const unresolvedCtxt = probeUnresolvedCtxt();
     const unresolved = new Set();
-    collectUnresolved(ast, unresolved);
+    collectUnresolved(ast, unresolvedCtxt, unresolved);
     for (const g of KNOWN_GLOBALS)
         unresolved.delete(g);
     if (unresolved.size === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",

package/src/cli.ts

@@ -105,6 +105,8 @@ if (opts['compare-baseline']) {
 
 const files = new Set((await Promise.all(patterns.map((pattern) => Array.fromAsync(glob(pattern, { cwd: process.cwd() })).catch(() => [] as string[])))).flat());
 
+const allBaselineResults: Record<string, Record<string, number>> = {};
+
 for (const file of files) {
   const stats = await stat(file).catch(() => false as const);
   if (stats && stats.isFile()) {
@@ -117,18 +119,28 @@ for (const file of files) {
       instance = Benchmark.create(...args);
       return instance;
     };
-    await import(identifier);
+    try {
+      await import(identifier);
+    } catch (e) {
+      console.error(`Error loading ${file}: ${e instanceof Error ? e.message : String(e)}`);
+      continue;
+    }
 
     if (instance) {
-      const reports = await instance.execute({
-        ...executeOptions,
-        [BENCHMARK_URL]: identifier,
-      } as typeof executeOptions);
+      let reports;
+      try {
+        reports = await instance.execute({
+          ...executeOptions,
+          [BENCHMARK_URL]: identifier,
+        } as typeof executeOptions);
+      } catch (e) {
+        console.error(`Error executing ${file}: ${e instanceof Error ? e.message : String(e)}`);
+        continue;
+      }
 
       if (opts['save-baseline']) {
-        const baselineData = reportsToBaseline(reports);
-        await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
-        console.log(`Baseline saved to: ${opts['save-baseline']}`);
+        const bd = reportsToBaseline(reports);
+        Object.assign(allBaselineResults, bd.results);
       }
 
       if (baseline) {
@@ -157,3 +169,13 @@ for (const file of files) {
     }
   }
 }
+
+if (opts['save-baseline'] && Object.keys(allBaselineResults).length > 0) {
+  const baselineData: BaselineData = {
+    version: 1,
+    timestamp: new Date().toISOString(),
+    results: allBaselineResults,
+  };
+  await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
+  console.log(`Baseline saved to: ${opts['save-baseline']}`);
+}

package/src/executor.ts

@@ -2,7 +2,7 @@ import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
 import { createReport, computeStats, Report } from './reporter.js';
-import { cmp, assertNoClosure } from './utils.js';
+import { cmp, assertNoClosure, normalizeFunction } from './utils.js';
 import {
   type ExecutorRunOptions,
   type ReportOptions,
@@ -43,6 +43,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
   const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
 
   const pending: { task: ExecutorRunOptions<TContext, TInput>; resolve: (v: unknown) => void; reject: (e: unknown) => void }[] = [];
+  const activeWorkers = new Set<Worker>();
   let running = 0;
 
   const schedule = async (task: ExecutorRunOptions<TContext, TInput>) => {
@@ -68,11 +69,11 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
   };
 
   const runTask = async ({ id, setup, teardown, pre, run, post, data }: ExecutorRunOptions<TContext, TInput>) => {
-    const setupCode = setup?.toString();
-    const teardownCode = teardown?.toString();
-    const preCode = pre?.toString();
-    const runCode = run.toString();
-    const postCode = post?.toString();
+    const setupCode = setup ? normalizeFunction(setup.toString()) : undefined;
+    const teardownCode = teardown ? normalizeFunction(teardown.toString()) : undefined;
+    const preCode = pre ? normalizeFunction(pre.toString()) : undefined;
+    const runCode = normalizeFunction(run.toString());
+    const postCode = post ? normalizeFunction(post.toString()) : undefined;
 
     if (setupCode) assertNoClosure(setupCode, 'setup');
     if (teardownCode) assertNoClosure(teardownCode, 'teardown');
@@ -106,6 +107,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     const worker = new Worker(workerFile, {
       workerData,
     });
+    activeWorkers.add(worker);
 
     const control = new Int32Array(controlSAB);
     let progressIntervalId: ReturnType<typeof setInterval> | undefined;
@@ -132,6 +134,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
       if (progressIntervalId) clearInterval(progressIntervalId);
       workerError = err instanceof Error ? err.message : String(err);
     }
+    activeWorkers.delete(worker);
 
     const count = control[Control.INDEX];
     const heapUsedKB = control[Control.HEAP_USED];
@@ -161,5 +164,13 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     return Object.fromEntries(report);
   };
 
-  return { pushAsync, kill() {} };
+  return {
+    pushAsync,
+    kill() {
+      for (const w of activeWorkers) w.terminate();
+      activeWorkers.clear();
+      for (const p of pending) p.reject(new Error('Executor killed'));
+      pending.length = 0;
+    },
+  };
 };

package/src/runner.ts

@@ -592,7 +592,6 @@ export const benchmark = async <TContext, TInput>({
       const durationNumber = Number(sampleDuration);
       if (!disableFiltering) {
         const { median, iqr } = medianAndIqr(outlierWindow);
-        pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
         const maxAllowed = median + OUTLIER_IQR_MULTIPLIER * iqr || Number.POSITIVE_INFINITY;
         if (outlierWindow.length >= 8 && durationNumber > maxAllowed && durationNumber - median > OUTLIER_ABS_THRESHOLD) {
           skipped++;
@@ -604,9 +603,8 @@ export const benchmark = async <TContext, TInput>({
           skipped++;
           continue;
         }
-      } else {
-        pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
       }
+      pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
 
       durations[i++] = sampleDuration;
       const deltaS = sampleDuration * WELFORD_SCALE - meanS;

package/src/utils.ts

@@ -45,11 +45,14 @@ export const max = (a: bigint, b: bigint) => {
 
 export function div(a: bigint, b: bigint, decimals: number = 2): string {
   if (b === 0n) throw new RangeError('Division by zero');
+  const neg = a < 0n !== b < 0n;
+  const absA = a < 0n ? -a : a;
+  const absB = b < 0n ? -b : b;
   const scale = 10n ** BigInt(decimals);
-  const scaled = (a * scale) / b;
+  const scaled = (absA * scale) / absB;
   const intPart = scaled / scale;
   const fracPart = scaled % scale;
-  return `${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
+  return `${neg ? '-' : ''}${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
 }
 
 export function divs(a: bigint, b: bigint, scale: bigint): bigint {
@@ -60,19 +63,68 @@ export function divs(a: bigint, b: bigint, scale: bigint): bigint {
 const KNOWN_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
 KNOWN_GLOBALS.add('arguments');
 
-function collectUnresolved(node: unknown, result: Set<string>) {
+let _unresolvedCtxt: number | undefined;
+
+function findIdentifierCtxt(node: unknown, name: string): number | undefined {
+  if (!node || typeof node !== 'object') return undefined;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      const r = findIdentifierCtxt(item, name);
+      if (r !== undefined) return r;
+    }
+    return undefined;
+  }
+  const obj = node as Record<string, unknown>;
+  if (obj.type === 'Identifier' && obj.value === name && typeof obj.ctxt === 'number') {
+    return obj.ctxt;
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === 'span') continue;
+    const r = findIdentifierCtxt(obj[key], name);
+    if (r !== undefined) return r;
+  }
+  return undefined;
+}
+
+function probeUnresolvedCtxt(): number {
+  if (_unresolvedCtxt !== undefined) return _unresolvedCtxt;
+  try {
+    const ast = parseSync('var _ = () => __PROBE__', { syntax: 'ecmascript', target: 'esnext' });
+    _unresolvedCtxt = findIdentifierCtxt(ast, '__PROBE__') ?? 1;
+  } catch {
+    _unresolvedCtxt = 1;
+  }
+  return _unresolvedCtxt;
+}
+
+function collectUnresolved(node: unknown, ctxt: number, result: Set<string>) {
   if (!node || typeof node !== 'object') return;
   if (Array.isArray(node)) {
-    for (const item of node) collectUnresolved(item, result);
+    for (const item of node) collectUnresolved(item, ctxt, result);
     return;
   }
   const obj = node as Record<string, unknown>;
-  if (obj.type === 'Identifier' && obj.ctxt === 1 && typeof obj.value === 'string') {
+  if (obj.type === 'Identifier' && obj.ctxt === ctxt && typeof obj.value === 'string') {
     result.add(obj.value);
   }
   for (const key of Object.keys(obj)) {
     if (key === 'span') continue;
-    collectUnresolved(obj[key], result);
+    collectUnresolved(obj[key], ctxt, result);
+  }
+}
+
+export function normalizeFunction(code: string): string {
+  try {
+    parseSync(`var __fn = ${code}`, { syntax: 'ecmascript', target: 'esnext' });
+    return code;
+  } catch {
+    const normalized = code.startsWith('async ') ? `async function ${code.slice(6)}` : `function ${code}`;
+    try {
+      parseSync(`var __fn = ${normalized}`, { syntax: 'ecmascript', target: 'esnext' });
+      return normalized;
+    } catch {
+      return code;
+    }
   }
 }
 
@@ -83,8 +135,9 @@ export function assertNoClosure(code: string, name: string): void {
   } catch {
     return;
   }
+  const unresolvedCtxt = probeUnresolvedCtxt();
   const unresolved = new Set<string>();
-  collectUnresolved(ast, unresolved);
+  collectUnresolved(ast, unresolvedCtxt, unresolved);
   for (const g of KNOWN_GLOBALS) unresolved.delete(g);
   if (unresolved.size === 0) return;