overtake 0.0.2 → 0.0.5

package/cli.js

@@ -1,23 +1,62 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --no-warnings
 
+import { Command } from 'commander';
 import { promisify } from 'util';
 import Path from 'path';
 import glob from 'glob';
-import { load, benchmark, setup, teardown, measure, perform, run, defaultReporter } from './index.js';
+import { load, createScript, benchmark, setup, teardown, measure, perform, run, defaultReporter } from './index.js';
+import packageJson from './package.json' assert { type: 'json' };
 
-const globAsync = promisify(glob);
-const pattern = process.argv[2] || '**/__benchmarks__/**/*.js';
+const commands = new Command();
 
-Object.assign(globalThis, { benchmark, setup, teardown, measure, perform });
+commands.name('overtake').description(packageJson.description).version(packageJson.version, '-v, --version');
 
-(async () => {
-  const files = await globAsync(pattern);
-  const scripts = [];
-  for (const file of files) {
-    const filename = Path.resolve(file);
-    const script = await load(filename);
-    scripts.push(script);
-  }
+commands
+  .argument('[files...]', 'file paths or path patterns to search benchmark scripts')
+  .option('-i, --inline [inline]', 'inline code to benchmark', (value, previous) => previous.concat([value]), [])
+  .option('-c, --count [count]', 'perform count for inline code', (v) => parseInt(v))
+  .action(async (patterns, { count = 1, inline }) => {
+    Object.assign(globalThis, { benchmark, setup, teardown, measure, perform });
 
-  await run(scripts, defaultReporter);
-})().catch((e) => console.error(e));
+    const globAsync = promisify(glob);
+    const foundFiles = await Promise.all(patterns.map((pattern) => globAsync(pattern)));
+    const files = [
+      ...new Set(
+        []
+          .concat(...foundFiles)
+          .map((filename) => Path.resolve(filename))
+          .filter(Boolean)
+      ),
+    ];
+
+    const scripts = [];
+    if (inline.length) {
+      const inlineScript = await createScript('', () => {
+        benchmark('', () => {
+          inline.forEach((code) => {
+            measure(code, `() => () => { ${code} }`);
+          });
+          perform('', count);
+        });
+      });
+      scripts.push(inlineScript);
+    }
+
+    for (const file of files) {
+      const filename = Path.resolve(file);
+      const script = await load(filename);
+      scripts.push(script);
+    }
+
+    await run(scripts, defaultReporter);
+  });
+
+commands.on('--help', () => {
+  console.log('');
+  console.log('Examples:');
+  console.log('  $ overtake **/__benchmarks__/*.js');
+  console.log('  $ overtake -i "class A{}" -i "function A(){}" -i "const A = () => {}" -c 1000000');
+  console.log('  $ overtake -v');
+});
+
+commands.parse(process.argv);

package/index.js

@@ -38,13 +38,18 @@ export const benchmark = (title, fn) => {
   });
 };
 
-export const load = async (filename) => {
+export const createScript = async (filename, fn) => {
   const suites = [];
   const script = { filename, suites };
-  await overtakeContext.contextualize(script, () => import(filename));
+  await overtakeContext.contextualize(script, fn);
 
   return script;
 };
+
+export const load = async (filename) => {
+  return createScript(filename, () => import(filename));
+};
+
 const map = {
   script: '⭐ Script ',
   suite: '⇶ Suite ',
@@ -54,7 +59,27 @@ const map = {
 
 export const defaultReporter = async (type, title, test) => {
   console.group(`${map[type]} ${title}`);
-  await test({ test: defaultReporter, output: (report) => console.table(report) });
+  await test({
+    test: defaultReporter,
+    output: (report) =>
+      console.table(
+        report.success
+          ? {
+              [formatFloat(report.mode)]: {
+                med: formatFloat(report.med),
+                p95: formatFloat(report.p95),
+                p99: formatFloat(report.p99),
+                total: formatFloat(report.sum),
+                count: report.count,
+              },
+            }
+          : {
+              error: {
+                reason: report.error,
+              },
+            }
+      ),
+  });
   console.groupEnd();
 };
 
@@ -80,22 +105,7 @@ export const run = async (scripts, reporter) => {
                     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,
-                      },
-                    });
-                  }
+                  measureTest.output(result);
                 });
               }
             });
@@ -140,8 +150,8 @@ export async function start(input) {
   const setup = Function(`return ${setupCode};`)();
   const teardown = Function(`return ${teardownCode};`)();
   const init = Function(`return ${initCode};`)();
+  const initArgsSize = init.length;
   const send = WorkerThreads.parentPort ? (data) => WorkerThreads.parentPort.postMessage(data) : (data) => console.log(data);
-
   let i = count;
   let done = FALSE_START;
 
@@ -153,11 +163,14 @@ export async function start(input) {
   const context = await setup();
   const setupMark = performance.now();
 
-  const initArgs = [() => done()];
-  if (init.length > 2) {
+  const initArgs = [];
+  if (initArgsSize !== 0) {
+    initArgs.push(() => done());
+  }
+  if (initArgsSize > 2) {
     initArgs.unshift(args);
   }
-  if (init.length > 1) {
+  if (initArgsSize > 1) {
     initArgs.unshift(context);
   }
 
@@ -188,6 +201,9 @@ export async function start(input) {
 
       const startTickTime = performance.now();
       action(...args[argIdx], idx);
+      if (!initArgsSize) {
+        done();
+      }
     };
     const cyclesMark = performance.now();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "NodeJS performance benchmark",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,7 +9,7 @@
     "overtake": "cli.js"
   },
   "scripts": {
-    "start": "node ./cli.js",
+    "start": "./cli.js",
     "test": "yarn node --experimental-vm-modules $(yarn bin jest) --detectOpenHandles",
     "lint": "eslint .",
     "prepare": "husky install"
@@ -39,6 +39,7 @@
     "pretty-quick": "^3.1.3"
   },
   "dependencies": {
+    "commander": "^9.2.0",
     "conode": "^0.1.0",
     "glob": "^8.0.1"
   }