benchmark each module in their own node process

Author: hoeck

README.md

@@ -74,3 +74,10 @@ function isMyDataValid(data: any) {
 // `res` is now type casted to the right type
 const res = isMyDataValid(data)
 ```
+
+## Local Development
+
+* `npm run start` - run benchmarks for all modules
+* `npm run start run zod myzod valita` - run benchmarks only for a few selected modules
+* `npm run docs:serve` - result viewer
+* `npm run test` - run tests on all modules

benchmarks/helpers/main.ts

@@ -1,5 +1,5 @@
 import { add, complete, cycle, suite } from 'benny';
-import { readFileSync, writeFileSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { writePreviewGraph } from './graph';
 import { getRegisteredBenchmarks } from './register';
@@ -10,15 +10,18 @@ const NODE_VERSION = process.env.NODE_VERSION || process.version;
 const NODE_VERSION_FOR_PREVIEW = 17;
 const TEST_PREVIEW_GENERATION = false;
 
-export async function main() {
+/**
+ * Run all registered benchmarks and append the results to a file.
+ */
+export async function runAllBenchmarks() {
   if (TEST_PREVIEW_GENERATION) {
-    // just generate the preview without using benchmark data from a previous run
+    // during development: generate the preview using benchmark data from a previous run
     const allResults: BenchmarkResult[] = JSON.parse(
       readFileSync(join(DOCS_DIR, 'results', 'node-17.json')).toString()
     ).results;
 
     await writePreviewGraph({
-      filename: join(DOCS_DIR, 'results', 'preview.svg'),
+      filename: previewSvgFilename(),
       values: allResults,
     });
 
@@ -42,24 +45,40 @@ export async function main() {
     });
   }
 
-  writeFileSync(
-    join(DOCS_DIR, 'results', `node-${majorVersion}.json`),
+  // collect results of isolated benchmark runs into a single file
+  appendResults(allResults);
+}
 
-    JSON.stringify({
-      results: allResults,
-    }),
+/**
+ * Remove the results json file.
+ */
+export function deleteResults() {
+  const fileName = resultsJsonFilename();
 
-    { encoding: 'utf8' }
-  );
+  if (existsSync(fileName)) {
+    unlinkSync(fileName);
+  }
+}
+
+/**
+ * Generate the preview svg shown in the readme.
+ */
+export async function createPreviewGraph() {
+  const majorVersion = getNodeMajorVersion();
 
   if (majorVersion === NODE_VERSION_FOR_PREVIEW) {
+    const allResults: BenchmarkResult[] = JSON.parse(
+      readFileSync(resultsJsonFilename()).toString()
+    ).results;
+
     await writePreviewGraph({
-      filename: join(DOCS_DIR, 'results', 'preview.svg'),
+      filename: previewSvgFilename(),
       values: allResults,
     });
   }
 }
 
+// run a benchmark fn with benny
 async function runBenchmarks(name: string, cases: BenchmarkCase[]) {
   const fns = cases.map(c => add(c.moduleName, () => c.run()));
 
@@ -74,6 +93,52 @@ async function runBenchmarks(name: string, cases: BenchmarkCase[]) {
   );
 }
 
+// append results to an existing file or create a new one
+function appendResults(results: BenchmarkResult[]) {
+  const fileName = resultsJsonFilename();
+  const existingResults: BenchmarkResult[] = existsSync(fileName)
+    ? JSON.parse(readFileSync(fileName).toString()).results
+    : [];
+
+  // check that we're appending unique data
+  const getKey = ({
+    benchmark,
+    name,
+    nodeVersion,
+  }: BenchmarkResult): string => {
+    return JSON.stringify({ benchmark, name, nodeVersion });
+  };
+  const existingResultsIndex = new Set(existingResults.map(r => getKey(r)));
+
+  results.forEach(r => {
+    if (existingResultsIndex.has(getKey(r))) {
+      console.error('Result %s already exists in', getKey(r), fileName);
+
+      throw new Error('Duplicate result in result json file');
+    }
+  });
+
+  writeFileSync(
+    fileName,
+
+    JSON.stringify({
+      results: [...existingResults, ...results],
+    }),
+
+    { encoding: 'utf8' }
+  );
+}
+
+function resultsJsonFilename() {
+  const majorVersion = getNodeMajorVersion();
+
+  return join(DOCS_DIR, 'results', `node-${majorVersion}.json`);
+}
+
+function previewSvgFilename() {
+  return join(DOCS_DIR, 'results', 'preview.svg');
+}
+
 function getNodeMajorVersion() {
   let majorVersion = 0;
 

benchmarks/index.ts

@@ -1,4 +1,8 @@
-export { main } from './helpers/main';
+export {
+  runAllBenchmarks,
+  createPreviewGraph,
+  deleteResults,
+} from './helpers/main';
 export {
   addCase,
   AvailableBenchmarksIds,

cases/index.ts

@@ -1,28 +1,36 @@
-import './ajv';
-import './bueno';
-import './class-validator';
-import './computed-types';
-import './decoders';
-import './io-ts';
-import './jointz';
-import './json-decoder';
-import './marshal';
-import './mojotech-json-type-validation';
-import './myzod';
-import './ok-computer';
-import './purify-ts';
-import './rulr';
-import './runtypes';
-import './simple-runtypes';
-import './spectypes';
-import './superstruct';
-import './suretype';
-import './toi';
-import './tson';
-import './ts-interface-checker';
-import './ts-json-validator';
-import './ts-utils';
-import './typeofweb-schema';
-import './valita';
-import './yup';
-import './zod';
+export const cases = [
+  'ajv',
+  'bueno',
+  'class-validator',
+  'computed-types',
+  'decoders',
+  'io-ts',
+  'jointz',
+  'json-decoder',
+  'marshal',
+  'mojotech-json-type-validation',
+  'myzod',
+  'ok-computer',
+  'purify-ts',
+  'rulr',
+  'runtypes',
+  'simple-runtypes',
+  'spectypes',
+  'superstruct',
+  'suretype',
+  'toi',
+  'ts-interface-checker',
+  'ts-json-validator',
+  'ts-utils',
+  'tson',
+  'typeofweb-schema',
+  'valita',
+  'yup',
+  'zod',
+] as const;
+
+export type CaseName = typeof cases[number];
+
+export async function importCase(caseName: CaseName) {
+  await import('./' + caseName);
+}

index.ts

@@ -1,4 +1,69 @@
-import { main } from './benchmarks';
-import './cases';
+import * as childProcess from 'child_process';
+import * as benchmarks from './benchmarks';
+import * as cases from './cases';
 
-main();
+async function main() {
+  // a runtype lib would be handy here to check the passed command names ;)
+  const [command, ...args] = process.argv.slice(2);
+
+  switch (command) {
+    case undefined:
+    case 'run':
+      // run the given or all benchmarks, each in its own node process, see
+      // https://github.com/moltar/typescript-runtime-type-benchmarks/issues/864
+      {
+        console.log('Removing previous results');
+        benchmarks.deleteResults();
+
+        const caseNames = args.length ? args : cases.cases;
+
+        for (let c of caseNames) {
+          if (c === 'spectypes') {
+            // hack: manually run the spectypes compilation step - avoids
+            // having to run it before any other benchmark, esp when working
+            // locally and checking against a few selected ones.
+            childProcess.execSync('npm run compile:spectypes', {
+              stdio: 'inherit',
+            });
+          }
+
+          const cmd = [...process.argv.slice(0, 2), 'run-internal', c];
+
+          console.log('Executing "%s"', c);
+          childProcess.execSync(cmd.join(' '), {
+            stdio: 'inherit',
+          });
+        }
+      }
+      break;
+
+    case 'create-preview-svg':
+      // separate command, because preview generation needs the accumulated
+      // results from the benchmark runs
+      await benchmarks.createPreviewGraph();
+      break;
+
+    case 'run-internal':
+      // run the given benchmark(s) & append the results
+      {
+        const caseNames = args as cases.CaseName[];
+
+        for (let c of caseNames) {
+          console.log('Loading "%s"', c);
+
+          await cases.importCase(c);
+        }
+
+        await benchmarks.runAllBenchmarks();
+      }
+      break;
+
+    default:
+      console.error('unknown command:', command);
+      process.exit(1);
+  }
+}
+
+main().catch(e => {
+  throw e;
+});

package.json

@@ -11,7 +11,7 @@
   "scripts": {
     "lint": "gts check",
     "lint:fix": "gts fix",
-    "start": "npm run compile:spectypes && ts-node index.ts",
+    "start": "ts-node index.ts",
     "test:build": "npm run compile:spectypes && tsc --noEmit",
     "test": "npm run compile:spectypes && jest",
     "docs:serve": "serve docs",

start.sh

@@ -4,4 +4,5 @@ set -ex
 
 export NODE_VERSION="${NODE_VERSION:-$(node -v)}"
 
-npm start
+npm run start
+npm run start create-preview-svg

test/benchmarks.test.ts

@@ -1,5 +1,48 @@
 import { getRegisteredBenchmarks } from '../benchmarks';
-import '../cases';
+import { cases } from '../cases';
+
+// all cases need to be imported here because jest cannot pic up dynamically
+// imported `test` and `describe`
+import '../cases/ajv';
+import '../cases/bueno';
+import '../cases/class-validator';
+import '../cases/computed-types';
+import '../cases/decoders';
+import '../cases/io-ts';
+import '../cases/jointz';
+import '../cases/json-decoder';
+import '../cases/marshal';
+import '../cases/mojotech-json-type-validation';
+import '../cases/myzod';
+import '../cases/ok-computer';
+import '../cases/purify-ts';
+import '../cases/rulr';
+import '../cases/runtypes';
+import '../cases/simple-runtypes';
+import '../cases/spectypes';
+import '../cases/superstruct';
+import '../cases/suretype';
+import '../cases/toi';
+import '../cases/ts-interface-checker';
+import '../cases/ts-json-validator';
+import '../cases/ts-utils';
+import '../cases/tson';
+import '../cases/typeofweb-schema';
+import '../cases/valita';
+import '../cases/yup';
+import '../cases/zod';
+
+test('all cases must have been imported in tests', () => {
+  const registeredCases = new Set<string>();
+
+  getRegisteredBenchmarks().forEach(([benchmarkId, benchmarkCases]) => {
+    benchmarkCases.forEach(b => {
+      registeredCases.add(b.moduleName);
+    });
+  });
+
+  expect(registeredCases.size).toEqual(cases.length);
+});
 
 getRegisteredBenchmarks().forEach(([benchmarkId, benchmarkCases]) => {
   describe(benchmarkId, () => {