overtake 2.0.2 → 2.1.0

package/build/cli.js

@@ -23,6 +23,7 @@ const { values: opts, positionals: patterns } = parseArgs({
         'max-cycles': { type: 'string' },
         'min-cycles': { type: 'string' },
         'no-gc-observer': { type: 'boolean' },
+        'pin-cores': { type: 'boolean' },
         progress: { type: 'boolean' },
         'save-baseline': { type: 'string' },
         'compare-baseline': { type: 'string' },
@@ -49,6 +50,7 @@ Options:
   --max-cycles <n>                maximum measurement cycles per feed
   --min-cycles <n>                minimum measurement cycles per feed
   --no-gc-observer                disable GC overlap detection
+  --pin-cores                     pin each worker to a dedicated CPU core (Linux)
   --progress                      show progress bar
   --save-baseline <file>          save results to baseline file
   --compare-baseline <file>       compare results against baseline file
@@ -69,6 +71,7 @@ const executeOptions = {
     maxCycles: opts['max-cycles'] ? parseInt(opts['max-cycles']) : undefined,
     minCycles: opts['min-cycles'] ? parseInt(opts['min-cycles']) : undefined,
     gcObserver: !opts['no-gc-observer'],
+    pinCores: opts['pin-cores'] ?? false,
     progress: opts.progress ?? false,
     format,
 };

package/build/executor.d.ts

@@ -9,6 +9,7 @@ export type ExecutorReport<R extends ReportTypeList> = Record<R[number], Report>
 export interface ExecutorOptions<R extends ReportTypeList> extends BenchmarkOptions, ReportOptions<R> {
     workers?: number;
     maxCycles?: number;
+    pinCores?: boolean;
     onProgress?: ProgressCallback;
     progressInterval?: number;
 }

package/build/executor.js

@@ -1,14 +1,21 @@
 import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
+import { cpus } from 'node:os';
 import { createReport, computeStats, Report } from './reporter.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) => {
-    const { workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, gcObserver = true, reportTypes, onProgress, progressInterval = 100 } = options;
+    const { workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, gcObserver = true, reportTypes, pinCores = false, onProgress, progressInterval = 100 } = options;
     const benchmarkUrl = options[BENCHMARK_URL];
     const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
+    let coreList = null;
+    if (pinCores) {
+        const count = cpus().length;
+        coreList = count > 1 ? Array.from({ length: count - 1 }, (_, i) => i + 1) : [0];
+    }
+    let nextCoreIdx = 0;
     const pending = [];
     const activeWorkers = new Set();
     let running = 0;
@@ -50,6 +57,7 @@ export const createExecutor = (options) => {
             assertNoClosure(postCode, 'post');
         const controlSAB = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * CONTROL_SLOTS);
         const durationsSAB = new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT * maxCycles);
+        const cpuPin = coreList !== null ? coreList[nextCoreIdx++ % coreList.length] : undefined;
         const workerFile = new URL('./worker.js', import.meta.url);
         const workerData = {
             benchmarkUrl: resolvedBenchmarkUrl,
@@ -59,6 +67,7 @@ export const createExecutor = (options) => {
             runCode,
             postCode,
             data,
+            cpuPin,
             warmupCycles,
             minCycles,
             absThreshold,
@@ -115,15 +124,16 @@ export const createExecutor = (options) => {
             }
         }
         const stats = count > 0 ? computeStats(durations) : undefined;
-        const report = reportTypes
+        const entries = reportTypes
             .map((type) => [type, createReport(durations, type, stats)])
             .concat([
             ['count', count],
             ['heapUsedKB', heapUsedKB],
             ['dceWarning', dceWarning],
-            ['error', workerError],
         ]);
-        return Object.fromEntries(report);
+        if (workerError)
+            entries.push(['error', workerError]);
+        return Object.fromEntries(entries);
     };
     return {
         pushAsync,

package/build/index.js

@@ -99,7 +99,7 @@ export class Benchmark {
         return new Target(target);
     }
     async execute(options = {}) {
-        const { workers = DEFAULT_WORKERS, warmupCycles = 20, maxCycles = DEFAULT_CYCLES, minCycles = 50, absThreshold = 1_000, relThreshold = 0.02, gcObserver = true, reportTypes = DEFAULT_REPORT_TYPES, progress = false, progressInterval = 100, } = options;
+        const { workers = DEFAULT_WORKERS, warmupCycles = 20, maxCycles = DEFAULT_CYCLES, minCycles = 50, absThreshold = 1_000, relThreshold = 0.02, gcObserver = true, reportTypes = DEFAULT_REPORT_TYPES, progress = false, progressInterval = 100, pinCores = false, } = options;
         if (this.#executed) {
             throw new Error("Benchmark is executed and can't be reused");
         }
@@ -134,6 +134,7 @@ export class Benchmark {
             relThreshold,
             gcObserver,
             reportTypes,
+            pinCores,
             onProgress,
             progressInterval,
             [BENCHMARK_URL]: benchmarkUrl,

package/build/loader-hook.d.ts

@@ -0,0 +1,2 @@
+export declare function resolve(specifier: string, context: unknown, nextResolve: (...args: unknown[]) => unknown): Promise<unknown>;
+export declare function load(url: string, context: unknown, nextLoad: (...args: unknown[]) => unknown): Promise<unknown>;

package/build/loader-hook.js

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from '@swc/core';
+export async function resolve(specifier, context, nextResolve) {
+    try {
+        return await nextResolve(specifier, context);
+    }
+    catch (e) {
+        if (specifier.endsWith('.js'))
+            try {
+                return await nextResolve(specifier.slice(0, -3) + '.ts', context);
+            }
+            catch { }
+        throw e;
+    }
+}
+export async function load(url, context, nextLoad) {
+    if (!url.endsWith('.ts') && !url.endsWith('.mts')) {
+        return nextLoad(url, context);
+    }
+    const filePath = fileURLToPath(url);
+    const rawSource = await readFile(filePath, 'utf-8');
+    const { code } = transformSync(rawSource, {
+        filename: filePath,
+        jsc: {
+            parser: { syntax: 'typescript' },
+            target: 'esnext',
+        },
+        module: { type: 'es6' },
+        sourceMaps: false,
+    });
+    return { format: 'module', source: code, shortCircuit: true };
+}

package/build/register-hook.js

@@ -1,15 +1,2 @@
 import { register } from 'node:module';
-async function resolve(s, c, n) {
-    try {
-        return await n(s, c);
-    }
-    catch (e) {
-        if (s.endsWith('.js'))
-            try {
-                return await n(s.slice(0, -3) + '.ts', c);
-            }
-            catch { }
-        throw e;
-    }
-}
-register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));
+register(new URL('../build/loader-hook.js', import.meta.url).href);

package/build/types.d.ts

@@ -46,6 +46,7 @@ export interface WorkerOptions extends Required<BenchmarkOptions> {
     runCode: string;
     postCode?: string;
     data?: unknown;
+    cpuPin?: number;
     durationsSAB: SharedArrayBuffer;
     controlSAB: SharedArrayBuffer;
 }

package/build/utils.js

@@ -1,18 +1,5 @@
 import { parseSync } from '@swc/core';
-async function resolve(s, c, n) {
-    try {
-        return await n(s, c);
-    }
-    catch (e) {
-        if (s.endsWith('.js'))
-            try {
-                return await n(s.slice(0, -3) + '.ts', c);
-            }
-            catch { }
-        throw e;
-    }
-}
-export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const resolveHookUrl = new URL('./loader-hook.js', import.meta.url).href;
 export const isqrt = (n) => {
     if (n < 0n)
         throw new RangeError('Square root of negative');
@@ -44,7 +31,7 @@ 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 neg = a < 0n !== b < 0n;
     const absA = a < 0n ? -a : a;
     const absB = b < 0n ? -b : b;
     const scale = 10n ** BigInt(decimals);

package/build/worker.js

@@ -2,12 +2,24 @@ import { workerData } from 'node:worker_threads';
 import { SourceTextModule, SyntheticModule } from 'node:vm';
 import { createRequire, register } from 'node:module';
 import { isAbsolute } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { benchmark } from './runner.js';
 import {} from './types.js';
 import { resolveHookUrl } from './utils.js';
 register(resolveHookUrl);
-const { benchmarkUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB, } = workerData;
+const { benchmarkUrl, setupCode, teardownCode, preCode, runCode, postCode, data, cpuPin, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB, } = workerData;
+if (cpuPin !== undefined && process.platform === 'linux') {
+    try {
+        const status = readFileSync('/proc/thread-self/status', 'utf8');
+        const tid = status.match(/^Pid:\t(\d+)/m)?.[1];
+        if (tid) {
+            execFileSync('taskset', ['-cp', String(cpuPin), tid], { stdio: 'ignore' });
+        }
+    }
+    catch { }
+}
 const serialize = (code) => (code ? code : 'undefined');
 const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
 const benchmarkDirUrl = new URL('.', resolvedBenchmarkUrl).href;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
@@ -12,7 +12,7 @@
     "overtake": "bin/overtake.js"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",

package/src/__tests__/fixtures/enum-bench.ts

@@ -0,0 +1,17 @@
+import 'overtake';
+
+const suite = benchmark('ops', () => null);
+
+const target = suite.target('enum', () => {
+  enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+  }
+  return { Direction };
+});
+
+target.measure('access', ({ Direction }) => {
+  return Direction.Up + Direction.Right;
+});

package/src/__tests__/fixtures/param-property-bench.ts

@@ -0,0 +1,14 @@
+import 'overtake';
+
+const suite = benchmark('ops', () => null);
+
+const target = suite.target('param-property', () => {
+  class Container {
+    constructor(public value: number) {}
+  }
+  return { Container };
+});
+
+target.measure('create', ({ Container }) => {
+  return new Container(42);
+});

package/src/__tests__/loader-hook.ts

@@ -0,0 +1,33 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+
+const exec = promisify(execFile);
+const overtakeBin = fileURLToPath(new URL('../../bin/overtake.js', import.meta.url));
+const nodeFlags = ['--experimental-vm-modules', '--no-warnings', '--expose-gc'];
+
+const runBench = async (fixture: string) => {
+  const { stdout } = await exec(process.execPath, [...nodeFlags, overtakeBin, '-f', 'json', '--max-cycles', '50', '--min-cycles', '10', '--warmup-cycles', '5', fixture], {
+    timeout: 30_000,
+  });
+
+  const result = JSON.parse(stdout);
+  const key = Object.keys(result)[0];
+  assert.ok(key, 'should have at least one benchmark result');
+  const feeds = result[key];
+  const feed = Object.keys(feeds)[0];
+  assert.ok(feeds[feed].ops, 'should have ops metric');
+  assert.ok(!feeds[feed].error, 'should not have an error');
+};
+
+describe('loader-hook', () => {
+  it('loads benchmark files using parameter properties', async () => {
+    await runBench(fileURLToPath(new URL('fixtures/param-property-bench.ts', import.meta.url)));
+  });
+
+  it('loads benchmark files using enums', async () => {
+    await runBench(fileURLToPath(new URL('fixtures/enum-bench.ts', import.meta.url)));
+  });
+});

package/src/cli.ts

@@ -39,6 +39,7 @@ const { values: opts, positionals: patterns } = parseArgs({
     'max-cycles': { type: 'string' },
     'min-cycles': { type: 'string' },
     'no-gc-observer': { type: 'boolean' },
+    'pin-cores': { type: 'boolean' },
     progress: { type: 'boolean' },
     'save-baseline': { type: 'string' },
     'compare-baseline': { type: 'string' },
@@ -67,6 +68,7 @@ Options:
   --max-cycles <n>                maximum measurement cycles per feed
   --min-cycles <n>                minimum measurement cycles per feed
   --no-gc-observer                disable GC overlap detection
+  --pin-cores                     pin each worker to a dedicated CPU core (Linux)
   --progress                      show progress bar
   --save-baseline <file>          save results to baseline file
   --compare-baseline <file>       compare results against baseline file
@@ -89,6 +91,7 @@ const executeOptions = {
   maxCycles: opts['max-cycles'] ? parseInt(opts['max-cycles']) : undefined,
   minCycles: opts['min-cycles'] ? parseInt(opts['min-cycles']) : undefined,
   gcObserver: !opts['no-gc-observer'],
+  pinCores: opts['pin-cores'] ?? false,
   progress: opts.progress ?? false,
   format,
 };

package/src/executor.ts

@@ -1,6 +1,7 @@
 import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
+import { cpus } from 'node:os';
 import { createReport, computeStats, Report } from './reporter.js';
 import { cmp, assertNoClosure, normalizeFunction } from './utils.js';
 import {
@@ -26,6 +27,7 @@ export type ExecutorReport<R extends ReportTypeList> = Record<R[number], Report>
 export interface ExecutorOptions<R extends ReportTypeList> extends BenchmarkOptions, ReportOptions<R> {
   workers?: number;
   maxCycles?: number;
+  pinCores?: boolean;
   onProgress?: ProgressCallback;
   progressInterval?: number;
 }
@@ -38,10 +40,17 @@ export interface Executor<TContext, TInput> {
 }
 
 export const createExecutor = <TContext, TInput, R extends ReportTypeList>(options: Required<ExecutorOptions<R>>): Executor<TContext, TInput> => {
-  const { workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, gcObserver = true, reportTypes, onProgress, progressInterval = 100 } = options;
+  const { workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, gcObserver = true, reportTypes, pinCores = false, onProgress, progressInterval = 100 } = options;
   const benchmarkUrl = (options as Record<symbol, unknown>)[BENCHMARK_URL];
   const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
 
+  let coreList: number[] | null = null;
+  if (pinCores) {
+    const count = cpus().length;
+    coreList = count > 1 ? Array.from({ length: count - 1 }, (_, i) => i + 1) : [0];
+  }
+  let nextCoreIdx = 0;
+
   const pending: { task: ExecutorRunOptions<TContext, TInput>; resolve: (v: unknown) => void; reject: (e: unknown) => void }[] = [];
   const activeWorkers = new Set<Worker>();
   let running = 0;
@@ -84,6 +93,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     const controlSAB = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * CONTROL_SLOTS);
     const durationsSAB = new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT * maxCycles);
 
+    const cpuPin = coreList !== null ? coreList[nextCoreIdx++ % coreList.length] : undefined;
     const workerFile = new URL('./worker.js', import.meta.url);
     const workerData: WorkerOptions = {
       benchmarkUrl: resolvedBenchmarkUrl,
@@ -93,6 +103,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
       runCode,
       postCode,
       data,
+      cpuPin,
 
       warmupCycles,
       minCycles,
@@ -153,15 +164,15 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     }
 
     const stats = count > 0 ? computeStats(durations) : undefined;
-    const report = reportTypes
+    const entries: [string, unknown][] = reportTypes
       .map<[string, unknown]>((type) => [type, createReport(durations, type, stats)] as [ReportType, Report])
       .concat([
         ['count', count],
         ['heapUsedKB', heapUsedKB],
         ['dceWarning', dceWarning],
-        ['error', workerError],
       ]);
-    return Object.fromEntries(report);
+    if (workerError) entries.push(['error', workerError]);
+    return Object.fromEntries(entries);
   };
 
   return {

package/src/index.ts

@@ -162,6 +162,7 @@ export class Benchmark<TInput> {
       reportTypes = DEFAULT_REPORT_TYPES as unknown as R,
       progress = false,
       progressInterval = 100,
+      pinCores = false,
     } = options;
     if (this.#executed) {
       throw new Error("Benchmark is executed and can't be reused");
@@ -201,6 +202,7 @@ export class Benchmark<TInput> {
       relThreshold,
       gcObserver,
       reportTypes,
+      pinCores,
       onProgress,
       progressInterval,
       [BENCHMARK_URL]: benchmarkUrl,

package/src/loader-hook.ts

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from '@swc/core';
+
+export async function resolve(specifier: string, context: unknown, nextResolve: (...args: unknown[]) => unknown) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (e) {
+    if (specifier.endsWith('.js'))
+      try {
+        return await nextResolve(specifier.slice(0, -3) + '.ts', context);
+      } catch {}
+    throw e;
+  }
+}
+
+export async function load(url: string, context: unknown, nextLoad: (...args: unknown[]) => unknown) {
+  if (!url.endsWith('.ts') && !url.endsWith('.mts')) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(url);
+  const rawSource = await readFile(filePath, 'utf-8');
+  const { code } = transformSync(rawSource, {
+    filename: filePath,
+    jsc: {
+      parser: { syntax: 'typescript' },
+      target: 'esnext',
+    },
+    module: { type: 'es6' },
+    sourceMaps: false,
+  });
+  return { format: 'module', source: code, shortCircuit: true };
+}

package/src/register-hook.ts

@@ -1,15 +1,3 @@
 import { register } from 'node:module';
 
-async function resolve(s: string, c: unknown, n: (...args: unknown[]) => unknown) {
-  try {
-    return await n(s, c);
-  } catch (e) {
-    if (s.endsWith('.js'))
-      try {
-        return await n(s.slice(0, -3) + '.ts', c);
-      } catch {}
-    throw e;
-  }
-}
-
-register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));
+register(new URL('../build/loader-hook.js', import.meta.url).href);

package/src/types.ts

@@ -89,6 +89,7 @@ export interface WorkerOptions extends Required<BenchmarkOptions> {
   runCode: string;
   postCode?: string;
   data?: unknown;
+  cpuPin?: number;
 
   durationsSAB: SharedArrayBuffer;
   controlSAB: SharedArrayBuffer;

package/src/utils.ts

@@ -1,18 +1,6 @@
 import { parseSync } from '@swc/core';
 
-async function resolve(s: string, c: unknown, n: (...args: unknown[]) => unknown) {
-  try {
-    return await n(s, c);
-  } catch (e) {
-    if (s.endsWith('.js'))
-      try {
-        return await n(s.slice(0, -3) + '.ts', c);
-      } catch {}
-    throw e;
-  }
-}
-
-export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const resolveHookUrl = new URL('./loader-hook.js', import.meta.url).href;
 
 export const isqrt = (n: bigint): bigint => {
   if (n < 0n) throw new RangeError('Square root of negative');

package/src/worker.ts

@@ -2,6 +2,8 @@ import { workerData } from 'node:worker_threads';
 import { SourceTextModule, SyntheticModule } from 'node:vm';
 import { createRequire, register } from 'node:module';
 import { isAbsolute } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { benchmark } from './runner.js';
 import { type WorkerOptions } from './types.js';
@@ -17,6 +19,7 @@ const {
   runCode,
   postCode,
   data,
+  cpuPin,
 
   warmupCycles,
   minCycles,
@@ -28,6 +31,16 @@ const {
   controlSAB,
 }: WorkerOptions = workerData;
 
+if (cpuPin !== undefined && process.platform === 'linux') {
+  try {
+    const status = readFileSync('/proc/thread-self/status', 'utf8');
+    const tid = status.match(/^Pid:\t(\d+)/m)?.[1];
+    if (tid) {
+      execFileSync('taskset', ['-cp', String(cpuPin), tid], { stdio: 'ignore' });
+    }
+  } catch {}
+}
+
 const serialize = (code?: string) => (code ? code : 'undefined');
 
 const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;