overtake 0.0.1-rc3 → 0.0.2

package/cli.js

@@ -1,19 +1,23 @@
 #!/usr/bin/env node
 
 import { promisify } from 'util';
+import Path from 'path';
 import glob from 'glob';
-import { Overtake } from './index.js';
-import { defaultReporter } from './reporter.js';
+import { load, benchmark, setup, teardown, measure, perform, run, defaultReporter } from './index.js';
 
 const globAsync = promisify(glob);
 const pattern = process.argv[2] || '**/__benchmarks__/**/*.js';
-const overtake = new Overtake({});
+
+Object.assign(globalThis, { benchmark, setup, teardown, measure, perform });
 
 (async () => {
   const files = await globAsync(pattern);
-  await overtake.load(files);
-  if (overtake.reporters.length === 0) {
-    reporter(defaultReporter);
+  const scripts = [];
+  for (const file of files) {
+    const filename = Path.resolve(file);
+    const script = await load(filename);
+    scripts.push(script);
   }
-  await overtake.run();
+
+  await run(scripts, defaultReporter);
 })().catch((e) => console.error(e));

package/index.d.ts

@@ -1,5 +1,3 @@
-import { Event } from 'evnty';
-
 declare global {
   type CanBePromise<T> = Promise<T> | T;
 
@@ -11,8 +9,15 @@ declare global {
     max: number;
     sum: number;
     avg: number;
-    med: number;
     mode: number;
+    p1: number;
+    p5: number;
+    p20: number;
+    p33: number;
+    p50: number;
+    med: number;
+    p66: number;
+    p80: number;
     p90: number;
     p95: number;
     p99: number;
@@ -23,52 +28,6 @@ declare global {
     total: number;
   }
 
-  interface Overtake {
-    onLoad: Event<any>;
-
-    onRun: Event<any>;
-
-    onComplete: Event<any>;
-
-    onScriptRegister: Event<any>;
-
-    onScriptStart: Event<any>;
-
-    onScriptComplete: Event<any>;
-
-    onSuiteRegister: Event<any>;
-
-    onSuiteStart: Event<any>;
-
-    onSuiteComplete: Event<any>;
-
-    onSetupRegister: Event<any>;
-
-    onTeardownRegister: Event<any>;
-
-    onMeasureRegister: Event<any>;
-
-    onMeasureStart: Event<any>;
-
-    onMeasureComplete: Event<any>;
-
-    onPerformRegister: Event<any>;
-
-    onPerformStart: Event<any>;
-
-    onPerformProgress: Event<any>;
-
-    onPerformComplete: Event<any>;
-
-    onReport: Event<Report>;
-  }
-
-  function benchmark(title: string, init: () => void): void;
-
-  function setup<C>(init: () => CanBePromise<C>): any;
-
-  function teardown<C>(teardown: (context: C) => CanBePromise<void>): void;
-
   type MeasureInitResult = CanBePromise<() => void>;
 
   function measure(title: string, init: () => MeasureInitResult): void;
@@ -78,5 +37,20 @@ declare global {
 
   function perform<A>(title: string, counter: number, args: A): void;
 
-  function reporter(reporter: (overtake: Overtake) => void): void;
+  function setup<C>(init: () => CanBePromise<C>): void;
+
+  function teardown<C>(teardown: (context: C) => CanBePromise<void>): void;
+
+  interface Suite {
+    title: string;
+    setup: typeof setup;
+    teardown: typeof teardown;
+    measures: typeof measure[];
+    performs: typeof perform[];
+    init: () => void;
+  }
+
+  function benchmark(title: string, init: () => void): void;
+
+  function script(filename): Promise<Suite[]>;
 }

package/index.js

@@ -1,183 +1,112 @@
-import Path from 'path';
+import { createContext } from 'conode';
 import WorkerThreads from 'worker_threads';
-import { Event } from 'evnty';
 
-export const NOOP = () => {};
-
-export class Perform {
-  title = '';
-
-  count = 0;
-
-  args;
-
-  constructor(overtake, title, count, args) {
-    this.title = title;
-    this.count = count;
-    this.args = args;
-  }
-}
-
-export class Measure {
-  title = '';
+const overtakeContext = createContext();
+const suiteContext = createContext();
 
-  init = NOOP;
-
-  constructor(overtake, title, init = NOOP) {
-    this.title = title;
-    this.init = init;
-  }
-}
-
-export class Suite {
-  title = '';
-
-  setup = NOOP;
-
-  measures = [];
-
-  performs = [];
+export const NOOP = () => {};
 
-  teardown = NOOP;
+export const setup = (fn) => {
+  suiteContext.getContext().setup = fn;
+};
 
-  #init = NOOP;
+export const teardown = (fn) => {
+  suiteContext.getContext().teardown = fn;
+};
 
-  #overtake = null;
+export const measure = (title, fn) => {
+  suiteContext.getContext().measures.push({ title, init: fn });
+};
 
-  constructor(overtake, title, init = NOOP) {
-    this.#overtake = overtake;
-    this.title = title;
-    this.#init = init;
-  }
+export const perform = (title, count, args) => {
+  suiteContext.getContext().performs.push({ title, count, args });
+};
 
-  async init() {
-    const unsubscribes = [
-      this.#overtake.onSetupRegister.on((setup) => (this.setup = setup)),
-      this.#overtake.onMeasureRegister.on((measure) => this.measures.push(measure)),
-      this.#overtake.onPerformRegister.on((perform) => this.performs.push(perform)),
-      this.#overtake.onTeardownRegister.on((teardown) => (this.teardown = teardown)),
-    ];
-    await this.#init();
-    unsubscribes.forEach((unsubscribe) => unsubscribe());
-  }
-}
+export const benchmark = (title, fn) => {
+  const setup = NOOP;
+  const teardown = NOOP;
+  const measures = [];
+  const performs = [];
+
+  overtakeContext.getContext().suites.push({
+    title,
+    setup,
+    teardown,
+    measures,
+    performs,
+    init: fn,
+  });
+};
 
-export class Script {
-  onLoad = new Event();
+export const load = async (filename) => {
+  const suites = [];
+  const script = { filename, suites };
+  await overtakeContext.contextualize(script, () => import(filename));
 
-  filename = '';
+  return script;
+};
+const map = {
+  script: '⭐ Script ',
+  suite: '⇶ Suite ',
+  perform: '➤ Perform ',
+  measure: '✓ Measure',
+};
 
-  suites = [];
+export const defaultReporter = async (type, title, test) => {
+  console.group(`${map[type]} ${title}`);
+  await test({ test: defaultReporter, output: (report) => console.table(report) });
+  console.groupEnd();
+};
 
-  constructor(filename) {
-    this.filename = filename;
-  }
+const ACCURACY = 6;
+export function formatFloat(value, digits = ACCURACY) {
+  return parseFloat(value.toFixed(digits));
 }
 
-export class Overtake {
-  onLoad = new Event();
-
-  onRun = new Event();
-
-  onComplete = new Event();
-
-  onScriptRegister = new Event();
-
-  onScriptStart = new Event();
-
-  onScriptComplete = new Event();
-
-  onSuiteRegister = new Event();
-
-  onSuiteStart = new Event();
-
-  onSuiteComplete = new Event();
-
-  onSetupRegister = new Event();
-
-  onTeardownRegister = new Event();
-
-  onMeasureRegister = new Event();
-
-  onMeasureStart = new Event();
-
-  onMeasureComplete = new Event();
-
-  onPerformRegister = new Event();
-
-  onPerformStart = new Event();
-
-  onPerformProgress = new Event();
-
-  onPerformComplete = new Event();
-
-  onReport = new Event();
-
-  scripts = [];
-
-  reporters = [];
-
-  constructor(options = {}) {
-    Object.assign(globalThis, {
-      benchmark: (title, init) => this.onSuiteRegister(new Suite(this, title, init)),
-      setup: (init) => this.onSetupRegister(init),
-      teardown: (init) => this.onTeardownRegister(init),
-      measure: (title, init) => this.onMeasureRegister(new Measure(this, title, init)),
-      perform: (title, count, args) => this.onPerformRegister(new Perform(this, title, count, args)),
-      reporter: (reporter) => this.reporters.push(reporter(this)),
-    });
-  }
-
-  async load(files) {
-    this.onLoad(this);
-    for (const file of files) {
-      const filename = Path.resolve(file);
-      const script = new Script(filename);
-      const unsubscribe = this.onSuiteRegister.on((suite) => {
-        script.suites.push(suite);
-      });
-      await import(filename);
-      unsubscribe();
-      this.scripts.push(script);
-      this.onScriptRegister(script);
-    }
-  }
-
-  async run() {
-    this.onRun();
-    for (const script of this.scripts) {
-      this.onScriptStart(script);
+export const run = async (scripts, reporter) => {
+  for (const script of scripts) {
+    await reporter('script', script.filename, async (scriptTest) => {
       for (const suite of script.suites) {
-        await suite.init().catch((e) => console.error(e));
-        this.onSuiteStart(suite);
-        for (const measure of suite.measures) {
-          this.onMeasureStart(measure);
+        await scriptTest.test('suite', suite.title, async (suiteTest) => {
+          await suiteContext.contextualize(suite, suite.init);
           for (const perform of suite.performs) {
-            this.onPerformStart(perform);
-            const result = await runWorker(
-              {
-                setup: suite.setup,
-                teardown: suite.teardown,
-                init: measure.init,
-                count: perform.count,
-                args: perform.args,
-              },
-              this.onPerformProgress
-            );
-            this.onPerformComplete(perform);
-            this.onReport(result);
+            await suiteTest.test('perform', perform.title, async (performTest) => {
+              for (const measure of suite.measures) {
+                await performTest.test('measure', measure.title, async (measureTest) => {
+                  const result = await runWorker({
+                    setup: suite.setup,
+                    teardown: suite.teardown,
+                    init: measure.init,
+                    count: perform.count,
+                    args: perform.args,
+                  });
+                  if (result.success) {
+                    measureTest.output({
+                      [formatFloat(result.mode)]: {
+                        total: formatFloat(result.total),
+                        med: formatFloat(result.med),
+                        p95: formatFloat(result.p95),
+                        p99: formatFloat(result.p99),
+                      },
+                    });
+                  } else {
+                    measureTest.output({
+                      error: {
+                        reason: result.error,
+                      },
+                    });
+                  }
+                });
+              }
+            });
           }
-          this.onMeasureComplete(perform);
-        }
-        this.onSuiteComplete(perform);
+        });
       }
-      this.onScriptComplete(perform);
-    }
-    this.onComplete(this);
+    });
   }
-}
+};
 
-export async function runWorker({ args, count, ...options }, onProgress) {
+export async function runWorker({ args, count, ...options }, onProgress = null) {
   const setupCode = options.setup.toString();
   const teardownCode = options.teardown.toString();
   const initCode = options.init.toString();
@@ -192,7 +121,7 @@ export async function runWorker({ args, count, ...options }, onProgress) {
   const worker = new WorkerThreads.Worker(new URL('runner.js', import.meta.url), { argv: [params] });
   return new Promise((resolve) => {
     worker.on('message', (data) => {
-      if (data.type === 'progress') {
+      if (onProgress && data.type === 'progress') {
         onProgress(data);
       } else if (data.type === 'report') {
         resolve(data);
@@ -292,14 +221,7 @@ export async function start(input) {
     });
     buckets.sort((a, b) => a[1] - b[1]);
 
-    const medIdx = Math.trunc((50 * timings.length) / 100);
-    const med = timings[medIdx];
-    const p90Idx = Math.trunc((90 * timings.length) / 100);
-    const p90 = timings[p90Idx];
-    const p95Idx = Math.trunc((95 * timings.length) / 100);
-    const p95 = timings[p95Idx];
-    const p99Idx = Math.trunc((99 * timings.length) / 100);
-    const p99 = timings[p99Idx];
+    const percentile = (p) => timings[Math.trunc((p * timings.length) / 100)];
     const mode = buckets[buckets.length - 1][0];
 
     send({
@@ -310,11 +232,19 @@ export async function start(input) {
       max,
       sum,
       avg,
-      med,
       mode,
-      p90,
-      p95,
-      p99,
+      p1: percentile(1),
+      p5: percentile(5),
+      p10: percentile(10),
+      p20: percentile(20),
+      p33: percentile(33),
+      p50: percentile(50),
+      med: percentile(50),
+      p66: percentile(66),
+      p80: percentile(80),
+      p90: percentile(90),
+      p95: percentile(95),
+      p99: percentile(99),
       setup: setupMark - startMark,
       init: initDoneMark - initMark,
       cycles: teardownMark - cyclesMark,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "0.0.1-rc3",
+  "version": "0.0.2",
   "description": "NodeJS performance benchmark",
   "main": "index.js",
   "types": "index.d.ts",
@@ -39,7 +39,7 @@
     "pretty-quick": "^3.1.3"
   },
   "dependencies": {
-    "evnty": "^0.7.4",
+    "conode": "^0.1.0",
     "glob": "^8.0.1"
   }
 }

package/reporter.js

@@ -1,90 +0,0 @@
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏', '⠿'];
-const SPINNER_INTERVAL = 100;
-const SPINNER_PADDING = 5;
-
-const ACCURACY = 6;
-
-/** TODO
- *  [PROGRESS] script/file.js
- *    Test suite title
- *      ➤ Measure
- *        ✓ Perform
- *        ✕ Perform
- * */
-
-const renderString = (message, x, direction) => {
-  const size = message.length;
-  process.stdout.moveCursor(0, -1);
-  process.stdout.cursorTo(x);
-  process.stdout.clearLine(direction);
-  if (direction === -1) {
-    process.stdout.cursorTo(0);
-  }
-  process.stdout.write(message);
-  process.stdout.moveCursor(-process.stdout.rows, 1);
-
-  return size;
-};
-
-const renderSpinner = (index) => renderString(SPINNER[index], 0, -1);
-
-const paddings = [];
-
-const renderMessage = (column, message) => {
-  const padding = SPINNER_PADDING + column * 10;
-  paddings[column + 1] = renderString(message, padding, 1);
-};
-
-export function formatFloat(value, digits = ACCURACY) {
-  return parseFloat(value.toFixed(digits));
-}
-
-export function defaultReporter(overtake) {
-  const spinnerSize = SPINNER.length - 1;
-  let i = 0;
-  let timerId = null;
-
-  overtake.onLoad.on(() => {});
-  overtake.onRun.on(() => {
-    console.log();
-  });
-  overtake.onComplete.on(() => {});
-  overtake.onScriptRegister.on(() => {});
-  overtake.onScriptStart.on(() => {});
-  overtake.onScriptComplete.on(() => {});
-  overtake.onSuiteRegister.on(() => {});
-  overtake.onSuiteStart.on(() => {});
-  overtake.onSuiteComplete.on(() => {});
-  overtake.onSetupRegister.on(() => {});
-  overtake.onTeardownRegister.on(() => {});
-  overtake.onMeasureRegister.on(() => {});
-  overtake.onMeasureStart.on((measure) => {
-    console.log(measure.title);
-  });
-  overtake.onMeasureComplete.on(() => {});
-  overtake.onPerformRegister.on(() => {});
-  overtake.onPerformStart.on((perform) => {
-    console.log(perform.title);
-    console.log();
-    i = 0;
-    timerId = setInterval(() => renderSpinner(i++ % spinnerSize), SPINNER_INTERVAL);
-  });
-  overtake.onPerformComplete.on(() => {
-    clearInterval(timerId);
-    renderSpinner(spinnerSize);
-  });
-  overtake.onPerformProgress.on(({ stage, progress }) => {
-    renderMessage(0, stage);
-    if (typeof progress !== 'undefined') {
-      renderMessage(1, `${(progress * 100).toFixed(0)}%`.padStart(4, ' '));
-    }
-  });
-  overtake.onReport.on((report) => {
-    if (report.success) {
-      renderMessage(2, `total:${report.total.toFixed(0)}ms  mode:${report.mode.toFixed(ACCURACY)}ms`);
-    } else {
-      renderMessage(1, report.error);
-    }
-    console.log();
-  });
-}