overtake 2.0.3 → 2.1.1

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,

package/build/index.d.ts

@@ -71,7 +71,7 @@ export declare const printHistogramReports: <R extends ReportTypeList>(reports:
 export interface BaselineData {
     version: number;
     timestamp: string;
-    results: Record<string, Record<string, number>>;
+    results: Record<string, Record<string, number | boolean>>;
 }
 export declare const reportsToBaseline: <R extends ReportTypeList>(reports: TargetReport<R>[]) => BaselineData;
 export declare const printComparisonReports: <R extends ReportTypeList>(reports: TargetReport<R>[], baseline: BaselineData, threshold?: number) => void;

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,
@@ -350,6 +351,19 @@ export const printComparisonReports = (reports, baseline, threshold = 5) => {
                         continue;
                     const current = value.valueOf();
                     const baselineValue = baselineData?.[metric];
+                    if (typeof current === 'boolean') {
+                        if (baselineValue === undefined) {
+                            console.log(`    * ${metric}: ${current} (new)`);
+                        }
+                        else if (current === Boolean(baselineValue)) {
+                            console.log(`      ${metric}: ${current}`);
+                        }
+                        else {
+                            const indicator = current ? '\x1b[31m!\x1b[0m' : '\x1b[32m+\x1b[0m';
+                            console.log(`    ${indicator} ${metric}: ${current} (was ${baselineValue})`);
+                        }
+                        continue;
+                    }
                     if (baselineValue !== undefined && baselineValue !== 0) {
                         const change = ((current - baselineValue) / baselineValue) * 100;
                         const isOps = metric === 'ops';

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/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.3",
+  "version": "2.1.1",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",

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,

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,
@@ -392,11 +394,11 @@ export const printHistogramReports = <R extends ReportTypeList>(reports: TargetR
 export interface BaselineData {
   version: number;
   timestamp: string;
-  results: Record<string, Record<string, number>>;
+  results: Record<string, Record<string, number | boolean>>;
 }
 
 export const reportsToBaseline = <R extends ReportTypeList>(reports: TargetReport<R>[]): BaselineData => {
-  const results: Record<string, Record<string, number>> = {};
+  const results: Record<string, Record<string, number | boolean>> = {};
   for (const report of reports) {
     for (const { measure, feeds } of report.measures) {
       for (const { feed, data } of feeds) {
@@ -439,8 +441,20 @@ export const printComparisonReports = <R extends ReportTypeList>(reports: Target
           const current = (value as { valueOf(): number }).valueOf();
           const baselineValue = baselineData?.[metric];
 
+          if (typeof current === 'boolean') {
+            if (baselineValue === undefined) {
+              console.log(`    * ${metric}: ${current} (new)`);
+            } else if (current === Boolean(baselineValue)) {
+              console.log(`      ${metric}: ${current}`);
+            } else {
+              const indicator = current ? '\x1b[31m!\x1b[0m' : '\x1b[32m+\x1b[0m';
+              console.log(`    ${indicator} ${metric}: ${current} (was ${baselineValue})`);
+            }
+            continue;
+          }
+
           if (baselineValue !== undefined && baselineValue !== 0) {
-            const change = ((current - baselineValue) / baselineValue) * 100;
+            const change = ((current - (baselineValue as number)) / (baselineValue as number)) * 100;
             const isOps = metric === 'ops';
             const improved = isOps ? change > threshold : change < -threshold;
             const regressed = isOps ? change < -threshold : change > threshold;

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/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;