overtake 0.1.2 → 1.0.0-rc.0

package/README.md

@@ -14,7 +14,6 @@ Performance benchmark for NodeJS
 - [Features](#features)
 - [Installing](#installing)
 - [Examples](#examples)
-- [Showcase](#showcase)
 - [License](#license)
 
 ## Features
@@ -25,10 +24,10 @@ Performance benchmark for NodeJS
 
 ## Installing
 
-Using yarn:
+Using pnpm:
 
 ```bash
-$ yarn add -D overtake
+$ pnpm add -D overtake
 ```
 
 Using npm:
@@ -39,101 +38,95 @@ $ npm install -D overtake
 
 ## Examples
 
-### Public interface
+### From command line
 
-Create a benchmark in `__benchmarks__` folder
+Create a benchmark file
 
-```javascript
-benchmark('mongodb vs postgres', () => {
-  // initialize a context for benchmark
-  setup(async () => {
-    const { Client } = await import('pg');
-    const postgres = new Client();
-    await postgres.connect();
+```typescript
+// src/__bench__/array-copy.ts
+const suite = benchmark('1M array of strings', () => Array.from({ length: 1_000_000 }, (_, idx) => `${idx}`))
+  .feed('1M array of numbers', () => Array.from({ length: 1_000_000 }, (_, idx) => idx))
+  .feed('1M typed array', () => new Uint32Array(1_000_000).map((_, idx) => idx));
 
-    const { MongoClient } = await import('mongob');
-    const mongo = new MongoClient(uri);
-    await mongo.connect();
-
-    return { postgres, mongo };
-  });
-
-  measure('mongodb inserts', ({ mongo } /* context */, next) => {
-    // prepare a collection
-    const database = mongo.db('overtake');
-    const test = database.collection('test');
-
-    return (data) => test.insertOne(data).then(next);
-  });
-
-  measure('postgres inserts', ({ postgres } /* context */, next) => {
-    // prepare a query
-    const query = 'INSERT INTO overtake(value) VALUES($1) RETURNING *';
-
-    return (data) => postgres.query(query, [data.value]).then(next);
-  });
-
-  teardown(async ({ mongo, postgres }) => {
-    await postgres.end();
-    await mongo.end();
-  });
+suite.target('for loop').measure('copy half', (_, input) => {
+  const n = input?.length ?? 0;
+  const mid = n / 2;
+  for (let i = 0; i < mid; i++) {
+    input[i + mid] = input[i];
+  }
+});
 
-  perform('simple test', 100000, [[{ value: 'test' }]]);
+suite.target('copyWithin').measure('copy half', (_, input) => {
+  const n = input?.length ?? 0;
+  const mid = n / 2;
+  input.copyWithin(mid, 0, mid);
 });
 ```
 
-Make sure you have installed used modules and run
+Run the command
 
 ```bash
-yarn overtake
+npx overtake src/__bench__/array-copy.ts -f table -r ops mode mean p99
 ```
 
-or
-
-```bash
-npx overtake
+```
+ for loop copy half
+┌─────────────────────┬──────────────────────┬─────────────┬─────────────┬─────────────────────┬────────┐
+│ (index)             │ ops                  │ mode        │ mean        │ p99                 │ count  │
+├─────────────────────┼──────────────────────┼─────────────┼─────────────┼─────────────────────┼────────┤
+│ 1M typed array      │ '3698 ops/s ± 0.81%' │ '256.65 µs' │ '270.38 µs' │ '574.7 µs ± 0.19%'  │ '1000' │
+│ 1M array of numbers │ '2902 ops/s ± 0.3%'  │ '343.92 µs' │ '344.51 µs' │ '429.24 µs ± 0.2%'  │ '1000' │
+│ 1M array of strings │ '2277 ops/s ± 0.46%' │ '397.15 µs' │ '438.99 µs' │ '569.15 µs ± 0.12%' │ '1000' │
+└─────────────────────┴──────────────────────┴─────────────┴─────────────┴─────────────────────┴────────┘
+
+ copyWithin copy half
+┌─────────────────────┬───────────────────────┬────────────┬────────────┬────────────────────┬────────┐
+│ (index)             │ ops                   │ mode       │ mean       │ p99                │ count  │
+├─────────────────────┼───────────────────────┼────────────┼────────────┼────────────────────┼────────┤
+│ 1M typed array      │ '17454 ops/s ± 0.67%' │ '53.11 µs' │ '57.29 µs' │ '81.18 µs ± 1.54%' │ '1000' │
+│ 1M array of numbers │ '103 ops/s ± 0.02%'   │ '9.49 ms'  │ '9.64 ms'  │ '9.91 ms ± 0.38%'  │ '50'   │
+│ 1M array of strings │ '101 ops/s ± 0.06%'   │ '9.55 ms'  │ '9.87 ms'  │ '10.87 ms ± 2.67%' │ '98'   │
+└─────────────────────┴───────────────────────┴────────────┴────────────┴────────────────────┴────────┘
 ```
 
-### Inline support
+### From a standalone module
 
-```bash
-npx overtake -i "class A{}" -i "function A() {}" -i "A = () => {};" -c 20000
-```
+Create a benchmark file
 
-```
-⭐ Script
-  ⇶ Suite
-    ➤ Perform
-      ✓ Measure class A{}
-        ┌─────────┬──────────┬──────────┬──────────┬───────────┬───────┐
-        │ (index) │   med    │   p95    │   p99    │   total   │ count │
-        ├─────────┼──────────┼──────────┼──────────┼───────────┼───────┤
-        │ 0.0005  │ 0.000551 │ 0.001493 │ 0.002344 │ 16.506385 │ 20000 │
-        └─────────┴──────────┴──────────┴──────────┴───────────┴───────┘
-      ✓ Measure function A() {}
-        ┌─────────┬─────────┬────────┬──────────┬──────────┬───────┐
-        │ (index) │   med   │  p95   │   p99    │  total   │ count │
-        ├─────────┼─────────┼────────┼──────────┼──────────┼───────┤
-        │ 0.00008 │ 0.00009 │ 0.0003 │ 0.000441 │ 2.875578 │ 20000 │
-        └─────────┴─────────┴────────┴──────────┴──────────┴───────┘
-      ✓ Measure A = () => {};
-        ┌─────────┬─────────┬──────────┬──────────┬─────────┬───────┐
-        │ (index) │   med   │   p95    │   p99    │  total  │ count │
-        ├─────────┼─────────┼──────────┼──────────┼─────────┼───────┤
-        │ 0.00008 │ 0.00012 │ 0.000331 │ 0.000601 │ 3.42556 │ 20000 │
-        └─────────┴─────────┴──────────┴──────────┴─────────┴───────┘
-```
+```typescript
+// src/__bench__/array-copy.js
+import { Benchmark, printTableReports } from 'overtake';
+
+const benchmark = Benchmark.create('1M array of strings', () => Array.from({ length: 1_000_000 }, (_, idx) => `${idx}`))
+  .feed('1M array of numbers', () => Array.from({ length: 1_000_000 }, (_, idx) => idx))
+  .feed('1M typed array', () => new Uint32Array(1_000_000).map((_, idx) => idx));
 
-Please take a look at [benchmarks](__benchmarks__) to see more examples
+benchmark.target('for loop').measure('copy half', (_, input) => {
+  const n = input?.length ?? 0;
+  const mid = n / 2;
+  for (let i = 0; i < mid; i++) {
+    input[i + mid] = input[i];
+  }
+});
 
-## Showcase
+benchmark.target('copyWithin').measure('copy half', (_, input) => {
+  const n = input?.length ?? 0;
+  const mid = n / 2;
+  input.copyWithin(mid, 0, mid);
+});
 
-Already measured performance
+const reports = await benchmark.execute({
+  reportTypes: ['ops', 'mode', 'mean', 'p99'],
+});
 
-- [Class vs Function](./overtakes/class-vs-function.md)
-- [Postgres vs MongoDB](./overtakes/postgres-vs-mongo.md)
-- [Array Copy](./overtakes/array-copy.md)
-- [Array Delete Element](./overtakes/array-delete-element.md)
+printTableReports(reports);
+```
+
+And run the command
+
+```bash
+node src/__bench__/array-copy.js
+```
 
 ## License
 

package/bin/overtake.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S node --experimental-vm-modules --no-warnings
+import '../build/cli.js';

package/build/__tests__/runner.d.ts

@@ -0,0 +1 @@
+export {};

package/build/benchmark.cjs

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AsyncFunction: function() {
+        return AsyncFunction;
+    },
+    Benchmark: function() {
+        return Benchmark;
+    },
+    DEFAULT_REPORT_TYPES: function() {
+        return DEFAULT_REPORT_TYPES;
+    },
+    DEFAULT_WORKERS: function() {
+        return DEFAULT_WORKERS;
+    },
+    FeedContext: function() {
+        return FeedContext;
+    },
+    Measure: function() {
+        return Measure;
+    },
+    MeasureContext: function() {
+        return MeasureContext;
+    },
+    Target: function() {
+        return Target;
+    },
+    TargetContext: function() {
+        return TargetContext;
+    },
+    printJSONReports: function() {
+        return printJSONReports;
+    },
+    printSimpleReports: function() {
+        return printSimpleReports;
+    },
+    printTableReports: function() {
+        return printTableReports;
+    }
+});
+const _nodeos = require("node:os");
+const _executorcjs = require("./executor.cjs");
+const _typescjs = require("./types.cjs");
+const DEFAULT_WORKERS = (0, _nodeos.cpus)().length;
+const AsyncFunction = (async ()=>{}).constructor;
+const DEFAULT_REPORT_TYPES = [
+    'ops'
+];
+class MeasureContext {
+    title;
+    run;
+    pre;
+    post;
+    constructor(title, run){
+        this.title = title;
+        this.run = run;
+    }
+}
+class Measure {
+    #ctx;
+    constructor(ctx){
+        this.#ctx = ctx;
+    }
+    pre(fn) {
+        this.#ctx.pre = fn;
+        return this;
+    }
+    post(fn) {
+        this.#ctx.post = fn;
+        return this;
+    }
+}
+class TargetContext {
+    title;
+    setup;
+    teardown;
+    measures;
+    constructor(title, setup){
+        this.title = title;
+        this.setup = setup;
+        this.measures = [];
+    }
+}
+class Target {
+    #ctx;
+    constructor(ctx){
+        this.#ctx = ctx;
+    }
+    teardown(fn) {
+        this.#ctx.teardown = fn;
+        return this;
+    }
+    measure(title, run) {
+        const measure = new MeasureContext(title, run);
+        this.#ctx.measures.push(measure);
+        return new Measure(measure);
+    }
+}
+class FeedContext {
+    title;
+    fn;
+    constructor(title, fn){
+        this.title = title;
+        this.fn = fn;
+    }
+}
+class Benchmark {
+    #targets = [];
+    #feeds = [];
+    #executed = false;
+    static create(title, fn) {
+        if (fn) {
+            return new Benchmark(title, fn);
+        } else {
+            return new Benchmark(title);
+        }
+    }
+    constructor(title, fn){
+        if (fn) {
+            this.feed(title, fn);
+        } else {
+            this.feed(title);
+        }
+    }
+    feed(title, fn) {
+        const self = this;
+        self.#feeds.push(fn ? new FeedContext(title, fn) : new FeedContext(title));
+        return self;
+    }
+    target(title, setup) {
+        const target = new TargetContext(title, setup);
+        this.#targets.push(target);
+        return new Target(target);
+    }
+    async execute({ workers = DEFAULT_WORKERS, warmupCycles = 20, maxCycles = _typescjs.DEFAULT_CYCLES, minCycles = 50, absThreshold = 1_000, relThreshold = 0.02, reportTypes = DEFAULT_REPORT_TYPES }) {
+        if (this.#executed) {
+            throw new Error('Benchmark is executed and can\'t be reused');
+        }
+        this.#executed = true;
+        const executor = (0, _executorcjs.createExecutor)({
+            workers,
+            warmupCycles,
+            maxCycles,
+            minCycles,
+            absThreshold,
+            relThreshold,
+            reportTypes
+        });
+        const reports = [];
+        for (const target of this.#targets){
+            const targetReport = {
+                target: target.title,
+                measures: []
+            };
+            for (const measure of target.measures){
+                const measureReport = {
+                    measure: measure.title,
+                    feeds: []
+                };
+                for (const feed of this.#feeds){
+                    const data = await feed.fn?.();
+                    executor.push({
+                        setup: target.setup,
+                        teardown: target.teardown,
+                        pre: measure.pre,
+                        run: measure.run,
+                        post: measure.post,
+                        data
+                    }).then((data)=>{
+                        measureReport.feeds.push({
+                            feed: feed.title,
+                            data
+                        });
+                    });
+                }
+                targetReport.measures.push(measureReport);
+            }
+            reports.push(targetReport);
+        }
+        await executor.drain();
+        executor.kill();
+        return reports;
+    }
+}
+const printSimpleReports = (reports)=>{
+    for (const report of reports){
+        for (const { measure, feeds } of report.measures){
+            console.group('\n', report.target, measure);
+            for (const { feed, data } of feeds){
+                const output = Object.entries(data).map(([key, report])=>`${key}: ${report.toString()}`).join('; ');
+                console.log(feed, output);
+            }
+            console.groupEnd();
+        }
+    }
+};
+const printTableReports = (reports)=>{
+    for (const report of reports){
+        for (const { measure, feeds } of report.measures){
+            console.log('\n', report.target, measure);
+            const table = {};
+            for (const { feed, data } of feeds){
+                table[feed] = Object.fromEntries(Object.entries(data).map(([key, report])=>[
+                        key,
+                        report.toString()
+                    ]));
+            }
+            console.table(table);
+        }
+    }
+};
+const printJSONReports = (reports, padding)=>{
+    const output = {};
+    for (const report of reports){
+        for (const { measure, feeds } of report.measures){
+            const row = {};
+            for (const { feed, data } of feeds){
+                row[feed] = Object.fromEntries(Object.entries(data).map(([key, report])=>[
+                        key,
+                        report.toString()
+                    ]));
+            }
+            output[`${report.target} ${measure}`] = row;
+        }
+    }
+    console.log(JSON.stringify(output, null, padding));
+};
+
+//# sourceMappingURL=benchmark.cjs.map

package/build/benchmark.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/benchmark.ts"],"sourcesContent":["import { cpus } from 'node:os';\nimport { createExecutor, ExecutorOptions, ExecutorReport } from './executor.js';\nimport { MaybePromise, StepFn, SetupFn, TeardownFn, FeedFn, ReportType, ReportTypeList, DEFAULT_CYCLES } from './types.js';\n\nexport const DEFAULT_WORKERS = cpus().length;\n\nexport const AsyncFunction = (async () => { }).constructor;\n\nexport interface TargetReport<R extends ReportTypeList> {\n  target: string;\n  measures: MeasureReport<R>[];\n}\n\nexport interface MeasureReport<R extends ReportTypeList> {\n  measure: string;\n  feeds: FeedReport<R>[];\n}\n\nexport interface FeedReport<R extends ReportTypeList> {\n  feed: string;\n  data: ExecutorReport<R>;\n}\n\nexport const DEFAULT_REPORT_TYPES = ['ops'] as const;\nexport type DefaultReportTypes = typeof DEFAULT_REPORT_TYPES[number];\n\nexport class MeasureContext<TContext, TInput> {\n  public pre?: StepFn<TContext, TInput>;\n  public post?: StepFn<TContext, TInput>;\n\n  constructor(\n    public title: string,\n    public run: StepFn<TContext, TInput>,\n  ) { }\n}\n\nexport class Measure<TContext, TInput> {\n  #ctx: MeasureContext<TContext, TInput>;\n\n  constructor(ctx: MeasureContext<TContext, TInput>) {\n    this.#ctx = ctx;\n  }\n\n  pre(fn: StepFn<TContext, TInput>): Measure<TContext, TInput> {\n    this.#ctx.pre = fn;\n    return this;\n  }\n  post(fn: StepFn<TContext, TInput>): Measure<TContext, TInput> {\n    this.#ctx.post = fn;\n    return this;\n  }\n}\n\nexport class TargetContext<TContext, TInput> {\n  public teardown?: TeardownFn<TContext>;\n  public measures: MeasureContext<TContext, TInput>[] = [];\n\n  constructor(\n    readonly title: string,\n    readonly setup?: SetupFn<MaybePromise<TContext>>,\n  ) {\n  }\n}\n\nexport class Target<TContext, TInput> {\n  #ctx: TargetContext<TContext, TInput>;\n\n  constructor(ctx: TargetContext<TContext, TInput>) {\n    this.#ctx = ctx;\n  }\n  teardown(fn: TeardownFn<TContext>): Target<TContext, TInput> {\n    this.#ctx.teardown = fn;\n\n    return this;\n  }\n  measure(title: string, run: StepFn<TContext, TInput>): Measure<TContext, TInput> {\n    const measure = new MeasureContext(title, run);\n    this.#ctx.measures.push(measure);\n\n    return new Measure(measure);\n  }\n}\n\nexport class FeedContext<TInput> {\n  constructor(\n    readonly title: string,\n    readonly fn?: FeedFn<TInput>,\n  ) { }\n}\n\nexport class Benchmark<TInput> {\n  #targets: TargetContext<unknown, TInput>[] = [];\n  #feeds: FeedContext<TInput>[] = [];\n  #executed = false;\n\n  static create(title: string): Benchmark<void>;\n  static create<I>(title: string, fn: FeedFn<I>): Benchmark<I>;\n  static create<I>(title: string, fn?: FeedFn<I> | undefined): Benchmark<I> {\n    if (fn) {\n      return new Benchmark(title, fn);\n    } else {\n      return new Benchmark(title);\n    }\n  }\n\n  constructor(title: string);\n  constructor(title: string, fn: FeedFn<TInput>);\n  constructor(title: string, fn?: FeedFn<TInput> | undefined) {\n    if (fn) {\n      this.feed(title, fn);\n    } else {\n      this.feed(title);\n    }\n  }\n\n  feed(title: string): Benchmark<TInput | void>;\n  feed<I>(title: string, fn: FeedFn<I>): Benchmark<TInput | I>;\n  feed<I>(title: string, fn?: FeedFn<I> | undefined): Benchmark<TInput | I> {\n    const self = (this as Benchmark<TInput | I>);\n    self.#feeds.push(\n      fn\n        ? new FeedContext(title, fn)\n        : new FeedContext(title)\n    );\n\n    return self;\n  }\n\n  target<TContext>(title: string): Target<void, TInput>;\n  target<TContext>(title: string, setup: SetupFn<Awaited<TContext>>): Target<TContext, TInput>;\n  target<TContext>(title: string, setup?: SetupFn<Awaited<TContext>> | undefined): Target<TContext, TInput> {\n    const target = new TargetContext<TContext, TInput>(title, setup);\n    this.#targets.push(target as TargetContext<unknown, TInput>);\n\n    return new Target<TContext, TInput>(target);\n  }\n\n  async execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>(\n    {\n      workers = DEFAULT_WORKERS,\n      warmupCycles = 20,\n      maxCycles = DEFAULT_CYCLES,\n      minCycles = 50,\n      absThreshold = 1_000,\n      relThreshold = 0.02,\n      reportTypes = DEFAULT_REPORT_TYPES as unknown as R,\n    }: ExecutorOptions<R>): Promise<TargetReport<R>[]> {\n    if (this.#executed) {\n      throw new Error('Benchmark is executed and can\\'t be reused');\n    }\n    this.#executed = true;\n\n    const executor = createExecutor<unknown, TInput, R>({\n      workers,\n      warmupCycles,\n      maxCycles,\n      minCycles,\n      absThreshold,\n      relThreshold,\n      reportTypes,\n    });\n\n    const reports: TargetReport<R>[] = [];\n    for (const target of this.#targets) {\n      const targetReport: TargetReport<R> = { target: target.title, measures: [] };\n      for (const measure of target.measures) {\n        const measureReport: MeasureReport<R> = { measure: measure.title, feeds: [] };\n        for (const feed of this.#feeds) {\n          const data = await feed.fn?.();\n          executor.push<ExecutorReport<R>>({\n            setup: target.setup,\n            teardown: target.teardown,\n            pre: measure.pre,\n            run: measure.run,\n            post: measure.post,\n            data,\n          }).then(data => {\n            measureReport.feeds.push({\n              feed: feed.title,\n              data,\n            });\n          });\n        }\n        targetReport.measures.push(measureReport);\n      }\n      reports.push(targetReport);\n    }\n    await executor.drain();\n    executor.kill();\n\n    return reports;\n  }\n}\n\nexport const printSimpleReports = <R extends ReportTypeList>(reports: TargetReport<R>[]) => {\n  for (const report of reports) {\n    for (const { measure, feeds } of report.measures) {\n      console.group('\\n', report.target, measure);\n      for (const { feed, data } of feeds) {\n        const output = Object.entries(data).map(([key, report]) => `${key}: ${report.toString()}`).join('; ');\n        console.log(feed, output);\n      }\n      console.groupEnd();\n    }\n  }\n};\n\nexport const printTableReports = <R extends ReportTypeList>(reports: TargetReport<R>[]) => {\n  for (const report of reports) {\n    for (const { measure, feeds } of report.measures) {\n      console.log('\\n', report.target, measure);\n      const table: Record<string, unknown> = {};\n      for (const { feed, data } of feeds) {\n        table[feed] = Object.fromEntries(Object.entries(data).map(([key, report]) => [key, report.toString()]));\n      }\n      console.table(table);\n    }\n  }\n};\n\nexport const printJSONReports = <R extends ReportTypeList>(reports: TargetReport<R>[], padding?: number) => {\n  const output = {} as Record<string, Record<string, Record<string, string>>>;\n  for (const report of reports) {\n    for (const { measure, feeds } of report.measures) {\n      const row = {} as Record<string, Record<string, string>>;\n      for (const { feed, data } of feeds) {\n        row[feed] = Object.fromEntries(Object.entries(data).map(([key, report]) => [key, report.toString()]));\n      }\n      output[`${report.target} ${measure}`] = row;\n    }\n  }\n  console.log(JSON.stringify(output, null, padding));\n};\n\n"],"names":["AsyncFunction","Benchmark","DEFAULT_REPORT_TYPES","DEFAULT_WORKERS","FeedContext","Measure","MeasureContext","Target","TargetContext","printJSONReports","printSimpleReports","printTableReports","cpus","length","constructor","pre","post","title","run","ctx","fn","teardown","measures","setup","measure","push","create","feed","self","target","execute","workers","warmupCycles","maxCycles","DEFAULT_CYCLES","minCycles","absThreshold","relThreshold","reportTypes","Error","executor","createExecutor","reports","targetReport","measureReport","feeds","data","then","drain","kill","report","console","group","output","Object","entries","map","key","toString","join","log","groupEnd","table","fromEntries","padding","row","JSON","stringify"],"mappings":";;;;;;;;;;;IAMaA,aAAa;eAAbA;;IAoFAC,SAAS;eAATA;;IAnEAC,oBAAoB;eAApBA;;IAnBAC,eAAe;eAAfA;;IA+EAC,WAAW;eAAXA;;IA/CAC,OAAO;eAAPA;;IAVAC,cAAc;eAAdA;;IAsCAC,MAAM;eAANA;;IAXAC,aAAa;eAAbA;;IAuKAC,gBAAgB;eAAhBA;;IA1BAC,kBAAkB;eAAlBA;;IAaAC,iBAAiB;eAAjBA;;;wBA/MQ;6BAC2C;0BAC8C;AAEvG,MAAMR,kBAAkBS,IAAAA,YAAI,IAAGC,MAAM;AAErC,MAAMb,gBAAgB,AAAC,CAAA,WAAc,CAAA,EAAGc,WAAW;AAiBnD,MAAMZ,uBAAuB;IAAC;CAAM;AAGpC,MAAMI;;;IACJS,IAA+B;IAC/BC,KAAgC;IAEvCF,YACE,AAAOG,KAAa,EACpB,AAAOC,GAA6B,CACpC;aAFOD,QAAAA;aACAC,MAAAA;IACL;AACN;AAEO,MAAMb;IACX,CAAA,GAAI,CAAmC;IAEvCS,YAAYK,GAAqC,CAAE;QACjD,IAAI,CAAC,CAAA,GAAI,GAAGA;IACd;IAEAJ,IAAIK,EAA4B,EAA6B;QAC3D,IAAI,CAAC,CAAA,GAAI,CAACL,GAAG,GAAGK;QAChB,OAAO,IAAI;IACb;IACAJ,KAAKI,EAA4B,EAA6B;QAC5D,IAAI,CAAC,CAAA,GAAI,CAACJ,IAAI,GAAGI;QACjB,OAAO,IAAI;IACb;AACF;AAEO,MAAMZ;;;IACJa,SAAgC;IAChCC,SAAkD;IAEzDR,YACE,AAASG,KAAa,EACtB,AAASM,KAAuC,CAChD;aAFSN,QAAAA;aACAM,QAAAA;aAJJD,WAA+C,EAAE;IAMxD;AACF;AAEO,MAAMf;IACX,CAAA,GAAI,CAAkC;IAEtCO,YAAYK,GAAoC,CAAE;QAChD,IAAI,CAAC,CAAA,GAAI,GAAGA;IACd;IACAE,SAASD,EAAwB,EAA4B;QAC3D,IAAI,CAAC,CAAA,GAAI,CAACC,QAAQ,GAAGD;QAErB,OAAO,IAAI;IACb;IACAI,QAAQP,KAAa,EAAEC,GAA6B,EAA6B;QAC/E,MAAMM,UAAU,IAAIlB,eAAeW,OAAOC;QAC1C,IAAI,CAAC,CAAA,GAAI,CAACI,QAAQ,CAACG,IAAI,CAACD;QAExB,OAAO,IAAInB,QAAQmB;IACrB;AACF;AAEO,MAAMpB;;;IACXU,YACE,AAASG,KAAa,EACtB,AAASG,EAAmB,CAC5B;aAFSH,QAAAA;aACAG,KAAAA;IACP;AACN;AAEO,MAAMnB;IACX,CAAA,OAAQ,GAAqC,EAAE,CAAC;IAChD,CAAA,KAAM,GAA0B,EAAE,CAAC;IACnC,CAAA,QAAS,GAAG,MAAM;IAIlB,OAAOyB,OAAUT,KAAa,EAAEG,EAA0B,EAAgB;QACxE,IAAIA,IAAI;YACN,OAAO,IAAInB,UAAUgB,OAAOG;QAC9B,OAAO;YACL,OAAO,IAAInB,UAAUgB;QACvB;IACF;IAIAH,YAAYG,KAAa,EAAEG,EAA+B,CAAE;QAC1D,IAAIA,IAAI;YACN,IAAI,CAACO,IAAI,CAACV,OAAOG;QACnB,OAAO;YACL,IAAI,CAACO,IAAI,CAACV;QACZ;IACF;IAIAU,KAAQV,KAAa,EAAEG,EAA0B,EAAyB;QACxE,MAAMQ,OAAQ,IAAI;QAClBA,KAAK,CAAA,KAAM,CAACH,IAAI,CACdL,KACI,IAAIhB,YAAYa,OAAOG,MACvB,IAAIhB,YAAYa;QAGtB,OAAOW;IACT;IAIAC,OAAiBZ,KAAa,EAAEM,KAA8C,EAA4B;QACxG,MAAMM,SAAS,IAAIrB,cAAgCS,OAAOM;QAC1D,IAAI,CAAC,CAAA,OAAQ,CAACE,IAAI,CAACI;QAEnB,OAAO,IAAItB,OAAyBsB;IACtC;IAEA,MAAMC,QACJ,EACEC,UAAU5B,eAAe,EACzB6B,eAAe,EAAE,EACjBC,YAAYC,wBAAc,EAC1BC,YAAY,EAAE,EACdC,eAAe,KAAK,EACpBC,eAAe,IAAI,EACnBC,cAAcpC,oBAAoC,EAC/B,EAA8B;QACnD,IAAI,IAAI,CAAC,CAAA,QAAS,EAAE;YAClB,MAAM,IAAIqC,MAAM;QAClB;QACA,IAAI,CAAC,CAAA,QAAS,GAAG;QAEjB,MAAMC,WAAWC,IAAAA,2BAAc,EAAqB;YAClDV;YACAC;YACAC;YACAE;YACAC;YACAC;YACAC;QACF;QAEA,MAAMI,UAA6B,EAAE;QACrC,KAAK,MAAMb,UAAU,IAAI,CAAC,CAAA,OAAQ,CAAE;YAClC,MAAMc,eAAgC;gBAAEd,QAAQA,OAAOZ,KAAK;gBAAEK,UAAU,EAAE;YAAC;YAC3E,KAAK,MAAME,WAAWK,OAAOP,QAAQ,CAAE;gBACrC,MAAMsB,gBAAkC;oBAAEpB,SAASA,QAAQP,KAAK;oBAAE4B,OAAO,EAAE;gBAAC;gBAC5E,KAAK,MAAMlB,QAAQ,IAAI,CAAC,CAAA,KAAM,CAAE;oBAC9B,MAAMmB,OAAO,MAAMnB,KAAKP,EAAE;oBAC1BoB,SAASf,IAAI,CAAoB;wBAC/BF,OAAOM,OAAON,KAAK;wBACnBF,UAAUQ,OAAOR,QAAQ;wBACzBN,KAAKS,QAAQT,GAAG;wBAChBG,KAAKM,QAAQN,GAAG;wBAChBF,MAAMQ,QAAQR,IAAI;wBAClB8B;oBACF,GAAGC,IAAI,CAACD,CAAAA;wBACNF,cAAcC,KAAK,CAACpB,IAAI,CAAC;4BACvBE,MAAMA,KAAKV,KAAK;4BAChB6B;wBACF;oBACF;gBACF;gBACAH,aAAarB,QAAQ,CAACG,IAAI,CAACmB;YAC7B;YACAF,QAAQjB,IAAI,CAACkB;QACf;QACA,MAAMH,SAASQ,KAAK;QACpBR,SAASS,IAAI;QAEb,OAAOP;IACT;AACF;AAEO,MAAMhC,qBAAqB,CAA2BgC;IAC3D,KAAK,MAAMQ,UAAUR,QAAS;QAC5B,KAAK,MAAM,EAAElB,OAAO,EAAEqB,KAAK,EAAE,IAAIK,OAAO5B,QAAQ,CAAE;YAChD6B,QAAQC,KAAK,CAAC,MAAMF,OAAOrB,MAAM,EAAEL;YACnC,KAAK,MAAM,EAAEG,IAAI,EAAEmB,IAAI,EAAE,IAAID,MAAO;gBAClC,MAAMQ,SAASC,OAAOC,OAAO,CAACT,MAAMU,GAAG,CAAC,CAAC,CAACC,KAAKP,OAAO,GAAK,GAAGO,IAAI,EAAE,EAAEP,OAAOQ,QAAQ,IAAI,EAAEC,IAAI,CAAC;gBAChGR,QAAQS,GAAG,CAACjC,MAAM0B;YACpB;YACAF,QAAQU,QAAQ;QAClB;IACF;AACF;AAEO,MAAMlD,oBAAoB,CAA2B+B;IAC1D,KAAK,MAAMQ,UAAUR,QAAS;QAC5B,KAAK,MAAM,EAAElB,OAAO,EAAEqB,KAAK,EAAE,IAAIK,OAAO5B,QAAQ,CAAE;YAChD6B,QAAQS,GAAG,CAAC,MAAMV,OAAOrB,MAAM,EAAEL;YACjC,MAAMsC,QAAiC,CAAC;YACxC,KAAK,MAAM,EAAEnC,IAAI,EAAEmB,IAAI,EAAE,IAAID,MAAO;gBAClCiB,KAAK,CAACnC,KAAK,GAAG2B,OAAOS,WAAW,CAACT,OAAOC,OAAO,CAACT,MAAMU,GAAG,CAAC,CAAC,CAACC,KAAKP,OAAO,GAAK;wBAACO;wBAAKP,OAAOQ,QAAQ;qBAAG;YACvG;YACAP,QAAQW,KAAK,CAACA;QAChB;IACF;AACF;AAEO,MAAMrD,mBAAmB,CAA2BiC,SAA4BsB;IACrF,MAAMX,SAAS,CAAC;IAChB,KAAK,MAAMH,UAAUR,QAAS;QAC5B,KAAK,MAAM,EAAElB,OAAO,EAAEqB,KAAK,EAAE,IAAIK,OAAO5B,QAAQ,CAAE;YAChD,MAAM2C,MAAM,CAAC;YACb,KAAK,MAAM,EAAEtC,IAAI,EAAEmB,IAAI,EAAE,IAAID,MAAO;gBAClCoB,GAAG,CAACtC,KAAK,GAAG2B,OAAOS,WAAW,CAACT,OAAOC,OAAO,CAACT,MAAMU,GAAG,CAAC,CAAC,CAACC,KAAKP,OAAO,GAAK;wBAACO;wBAAKP,OAAOQ,QAAQ;qBAAG;YACrG;YACAL,MAAM,CAAC,GAAGH,OAAOrB,MAAM,CAAC,CAAC,EAAEL,SAAS,CAAC,GAAGyC;QAC1C;IACF;IACAd,QAAQS,GAAG,CAACM,KAAKC,SAAS,CAACd,QAAQ,MAAMW;AAC3C"}

package/build/benchmark.d.ts

@@ -0,0 +1,64 @@
+import { ExecutorOptions, ExecutorReport } from './executor.js';
+import { MaybePromise, StepFn, SetupFn, TeardownFn, FeedFn, ReportType, ReportTypeList } from './types.js';
+export declare const DEFAULT_WORKERS: number;
+export declare const AsyncFunction: Function;
+export interface TargetReport<R extends ReportTypeList> {
+    target: string;
+    measures: MeasureReport<R>[];
+}
+export interface MeasureReport<R extends ReportTypeList> {
+    measure: string;
+    feeds: FeedReport<R>[];
+}
+export interface FeedReport<R extends ReportTypeList> {
+    feed: string;
+    data: ExecutorReport<R>;
+}
+export declare const DEFAULT_REPORT_TYPES: readonly ["ops"];
+export type DefaultReportTypes = typeof DEFAULT_REPORT_TYPES[number];
+export declare class MeasureContext<TContext, TInput> {
+    title: string;
+    run: StepFn<TContext, TInput>;
+    pre?: StepFn<TContext, TInput>;
+    post?: StepFn<TContext, TInput>;
+    constructor(title: string, run: StepFn<TContext, TInput>);
+}
+export declare class Measure<TContext, TInput> {
+    #private;
+    constructor(ctx: MeasureContext<TContext, TInput>);
+    pre(fn: StepFn<TContext, TInput>): Measure<TContext, TInput>;
+    post(fn: StepFn<TContext, TInput>): Measure<TContext, TInput>;
+}
+export declare class TargetContext<TContext, TInput> {
+    readonly title: string;
+    readonly setup?: SetupFn<MaybePromise<TContext>> | undefined;
+    teardown?: TeardownFn<TContext>;
+    measures: MeasureContext<TContext, TInput>[];
+    constructor(title: string, setup?: SetupFn<MaybePromise<TContext>> | undefined);
+}
+export declare class Target<TContext, TInput> {
+    #private;
+    constructor(ctx: TargetContext<TContext, TInput>);
+    teardown(fn: TeardownFn<TContext>): Target<TContext, TInput>;
+    measure(title: string, run: StepFn<TContext, TInput>): Measure<TContext, TInput>;
+}
+export declare class FeedContext<TInput> {
+    readonly title: string;
+    readonly fn?: FeedFn<TInput> | undefined;
+    constructor(title: string, fn?: FeedFn<TInput> | undefined);
+}
+export declare class Benchmark<TInput> {
+    #private;
+    static create(title: string): Benchmark<void>;
+    static create<I>(title: string, fn: FeedFn<I>): Benchmark<I>;
+    constructor(title: string);
+    constructor(title: string, fn: FeedFn<TInput>);
+    feed(title: string): Benchmark<TInput | void>;
+    feed<I>(title: string, fn: FeedFn<I>): Benchmark<TInput | I>;
+    target<TContext>(title: string): Target<void, TInput>;
+    target<TContext>(title: string, setup: SetupFn<Awaited<TContext>>): Target<TContext, TInput>;
+    execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>({ workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, reportTypes, }: ExecutorOptions<R>): Promise<TargetReport<R>[]>;
+}
+export declare const printSimpleReports: <R extends ReportTypeList>(reports: TargetReport<R>[]) => void;
+export declare const printTableReports: <R extends ReportTypeList>(reports: TargetReport<R>[]) => void;
+export declare const printJSONReports: <R extends ReportTypeList>(reports: TargetReport<R>[], padding?: number) => void;