overtake 1.0.0-rc.2 → 1.0.0-rc.3

package/overtakes/array-delete-element.md

@@ -1,44 +0,0 @@
-# Array delete element
-
-```
-⭐ Script  __benchmarks__/array-delete-element.js
-  ⇶ Suite  Array delete element methods
-    ➤ Perform  10 elements
-      ✓ Measure 500000 splice
-        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
-        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
-        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
-        │ 0.000072 │ 0.000078 │ 0.000121 │ 0.000248 │ 57.628642 │ 500000 │
-        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
-      ✓ Measure 500000 filter
-        ┌──────────┬──────────┬─────────┬──────────┬───────────┬────────┐
-        │ (index)  │   med    │   p95   │   p99    │   total   │ count  │
-        ├──────────┼──────────┼─────────┼──────────┼───────────┼────────┤
-        │ 0.000067 │ 0.000077 │ 0.00018 │ 0.000303 │ 51.695539 │ 500000 │
-        └──────────┴──────────┴─────────┴──────────┴───────────┴────────┘
-      ✓ Measure 500000 for loop
-        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
-        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
-        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
-        │ 0.000064 │ 0.000074 │ 0.000119 │ 0.000307 │ 44.446428 │ 500000 │
-        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
-    ➤ Perform  1000 elements
-      ✓ Measure 500000 splice
-        ┌─────────┬──────────┬──────────┬──────────┬───────────┬────────┐
-        │ (index) │   med    │   p95    │   p99    │   total   │ count  │
-        ├─────────┼──────────┼──────────┼──────────┼───────────┼────────┤
-        │ 0.00007 │ 0.000076 │ 0.000121 │ 0.000268 │ 54.328497 │ 500000 │
-        └─────────┴──────────┴──────────┴──────────┴───────────┴────────┘
-      ✓ Measure 500000 filter
-        ┌──────────┬──────────┬──────────┬─────────┬────────────┬────────┐
-        │ (index)  │   med    │   p95    │   p99   │   total    │ count  │
-        ├──────────┼──────────┼──────────┼─────────┼────────────┼────────┤
-        │ 0.002064 │ 0.002521 │ 0.003448 │ 0.00804 │ 1571.98239 │ 500000 │
-        └──────────┴──────────┴──────────┴─────────┴────────────┴────────┘
-      ✓ Measure 500000 for loop
-        ┌──────────┬──────────┬──────────┬─────────┬─────────────┬────────┐
-        │ (index)  │   med    │   p95    │   p99   │    total    │ count  │
-        ├──────────┼──────────┼──────────┼─────────┼─────────────┼────────┤
-        │ 0.002166 │ 0.002625 │ 0.003383 │ 0.00448 │ 1578.507514 │ 500000 │
-        └──────────┴──────────┴──────────┴─────────┴─────────────┴────────┘
-```

package/overtakes/async.md

@@ -1,25 +0,0 @@
-# Async functions call performance
-
-```
-⭐ Script  __benchmarks__/async.js
-  ⇶ Suite  Async functions performance
-    ➤ Perform  10000000 calls
-      ✓ Measure 10000000 calls of function that returns Promise.resolve()
-        ┌─────────┬──────────┬──────────┬─────────┬─────────────┬──────────┐
-        │ (index) │ med      │ p95      │ p99     │ total       │ count    │
-        ├─────────┼──────────┼──────────┼─────────┼─────────────┼──────────┤
-        │ 0.00008 │ 0.000093 │ 0.000138 │ 0.00023 │ 1189.475052 │ 10000000 │
-        └─────────┴──────────┴──────────┴─────────┴─────────────┴──────────┘
-      ✓ Measure 10000000 calls of async function that returns await Promise.resolve()
-        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬──────────┐
-        │ (index)  │ med      │ p95      │ p99      │ total       │ count    │
-        ├──────────┼──────────┼──────────┼──────────┼─────────────┼──────────┤
-        │ 0.000108 │ 0.000122 │ 0.000267 │ 0.000389 │ 1735.581918 │ 10000000 │
-        └──────────┴──────────┴──────────┴──────────┴─────────────┴──────────┘
-      ✓ Measure 10000000 calls of async function that returns Promise.resolve()
-        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬──────────┐
-        │ (index)  │ med      │ p95      │ p99      │ total       │ count    │
-        ├──────────┼──────────┼──────────┼──────────┼─────────────┼──────────┤
-        │ 0.000105 │ 0.000125 │ 0.000203 │ 0.000333 │ 1557.773513 │ 10000000 │
-        └──────────┴──────────┴──────────┴──────────┴─────────────┴──────────┘
-```

package/overtakes/class-vs-function.md

@@ -1,31 +0,0 @@
-# Class vs Function
-
-```
-⭐ Script  __benchmarks__/class-vs-function.js
-  ⇶ Suite  Class vs Function
-    ➤ Perform  Instantiation
-      ✓ Measure 1000000 class declarations via "class"
-        ┌──────────┬──────────┬──────────┬──────────┬───────────┬─────────┐
-        │ (index)  │   med    │   p95    │   p99    │   total   │  count  │
-        ├──────────┼──────────┼──────────┼──────────┼───────────┼─────────┤
-        │ 0.000438 │ 0.000496 │ 0.001133 │ 0.001602 │ 684.87052 │ 1000000 │
-        └──────────┴──────────┴──────────┴──────────┴───────────┴─────────┘
-      ✓ Measure 1000000 instantiations of the declared class via class and test method call
-        ┌──────────┬──────────┬──────────┬──────────┬───────────┬─────────┐
-        │ (index)  │   med    │   p95    │   p99    │   total   │  count  │
-        ├──────────┼──────────┼──────────┼──────────┼───────────┼─────────┤
-        │ 0.000048 │ 0.000054 │ 0.000059 │ 0.000137 │ 61.055298 │ 1000000 │
-        └──────────┴──────────┴──────────┴──────────┴───────────┴─────────┘
-      ✓ Measure 1000000 class declarations via function
-        ┌─────────┬──────────┬─────────┬──────────┬──────────┬─────────┐
-        │ (index) │   med    │   p95   │   p99    │  total   │  count  │
-        ├─────────┼──────────┼─────────┼──────────┼──────────┼─────────┤
-        │ 0.00005 │ 0.000056 │ 0.00007 │ 0.000146 │ 63.94922 │ 1000000 │
-        └─────────┴──────────┴─────────┴──────────┴──────────┴─────────┘
-      ✓ Measure 1000000 instantiations of the declared class via function and test method call
-        ┌──────────┬──────────┬─────────┬──────────┬───────────┬─────────┐
-        │ (index)  │   med    │   p95   │   p99    │   total   │  count  │
-        ├──────────┼──────────┼─────────┼──────────┼───────────┼─────────┤
-        │ 0.000049 │ 0.000056 │ 0.00008 │ 0.000189 │ 78.511849 │ 1000000 │
-        └──────────┴──────────┴─────────┴──────────┴───────────┴─────────┘
-```

package/overtakes/postgres-vs-mongo.md

@@ -1,55 +0,0 @@
-### Postgres vs MongoDB
-
-```
-⭐ Script  __benchmarks__/postgres-vs-mongo.js
-  ⇶ Suite  mongodb vs postgres
-    ➤ Perform  simple test
-      ✓ Measure 1000 postgres inserts
-        ┌──────────┬──────────┬──────────┬─────────┬─────────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99   │    total    │ count │
-        ├──────────┼──────────┼──────────┼─────────┼─────────────┼───────┤
-        │ 2.232527 │ 2.256009 │ 2.917856 │ 5.41444 │ 2408.708534 │ 1000  │
-        └──────────┴──────────┴──────────┴─────────┴─────────────┴───────┘
-      ✓ Measure 1000 mongodb inserts
-        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99    │    total    │ count │
-        ├──────────┼──────────┼──────────┼──────────┼─────────────┼───────┤
-        │ 2.955035 │ 2.981828 │ 5.038826 │ 5.467477 │ 3233.680552 │ 1000  │
-        └──────────┴──────────┴──────────┴──────────┴─────────────┴───────┘
-      ✓ Measure 1000 postgres query data
-        ┌─────────┬──────────┬──────────┬──────────┬────────────┬───────┐
-        │ (index) │   med    │   p95    │   p99    │   total    │ count │
-        ├─────────┼──────────┼──────────┼──────────┼────────────┼───────┤
-        │ 0.28218 │ 0.297544 │ 0.393615 │ 0.561729 │ 308.713494 │ 1000  │
-        └─────────┴──────────┴──────────┴──────────┴────────────┴───────┘
-      ✓ Measure 1000 mongodb query data
-        ┌──────────┬──────────┬──────────┬──────────┬───────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99    │   total   │ count │
-        ├──────────┼──────────┼──────────┼──────────┼───────────┼───────┤
-        │ 0.457289 │ 0.461665 │ 0.693627 │ 0.919116 │ 495.27099 │ 1000  │
-        └──────────┴──────────┴──────────┴──────────┴───────────┴───────┘
-      ✓ Measure 1000 postgres query inserts
-        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99    │    total    │ count │
-        ├──────────┼──────────┼──────────┼──────────┼─────────────┼───────┤
-        │ 2.491574 │ 2.500577 │ 3.524734 │ 6.177946 │ 2681.101875 │ 1000  │
-        └──────────┴──────────┴──────────┴──────────┴─────────────┴───────┘
-      ✓ Measure 1000 mongodb query inserts
-        ┌──────────┬──────────┬──────────┬─────────┬─────────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99   │    total    │ count │
-        ├──────────┼──────────┼──────────┼─────────┼─────────────┼───────┤
-        │ 3.946823 │ 3.921073 │ 5.969672 │ 6.26903 │ 3954.008642 │ 1000  │
-        └──────────┴──────────┴──────────┴─────────┴─────────────┴───────┘
-      ✓ Measure 1000 postgres group data
-        ┌──────────┬──────────┬──────────┬──────────┬────────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99    │   total    │ count │
-        ├──────────┼──────────┼──────────┼──────────┼────────────┼───────┤
-        │ 0.287954 │ 0.272375 │ 0.347489 │ 0.494122 │ 279.076014 │ 1000  │
-        └──────────┴──────────┴──────────┴──────────┴────────────┴───────┘
-      ✓ Measure 1000 mongodb group data
-        ┌──────────┬──────────┬──────────┬──────────┬────────────┬───────┐
-        │ (index)  │   med    │   p95    │   p99    │   total    │ count │
-        ├──────────┼──────────┼──────────┼──────────┼────────────┼───────┤
-        │ 0.564809 │ 0.556707 │ 0.666702 │ 0.851308 │ 569.134585 │ 1000  │
-        └──────────┴──────────┴──────────┴──────────┴────────────┴───────┘
-```

package/src/__tests__/runner.ts

@@ -1,34 +0,0 @@
-import { Benchmark } from '../benchmark.js';
-
-const benchmark = Benchmark.create('void')
-  .feed('strings', () => ['a', 'b', 'c'])
-  .feed('numbers', () => [0, 1, 2]);
-
-const httpServer = benchmark.target('node http', async () => {
-  const { createServer, Server } = await import('node:http');
-  const server = createServer();
-  return new Promise<InstanceType<typeof Server>>((resolve) => {
-    server.on('listen', () => resolve(server));
-  });
-});
-
-httpServer.teardown((ctx) => {
-  ctx.close();
-});
-
-httpServer
-  .measure('something to bench', async (ctx, input) => {
-    ctx.emit('whatever', input);
-  })
-  .pre(async (ctx, input) => {})
-  .post(async (ctx, input) => {});
-
-const forLoop = benchmark.target('for loop');
-
-forLoop
-  .measure('1k', (_, input) => {
-    const n = input?.length ?? 0;
-    for (let i = 0; i < n; i++) {}
-  })
-  .pre(async (ctx, input) => {})
-  .post(async (ctx, input) => {});

package/src/benchmark.ts

@@ -1,231 +0,0 @@
-import { cpus } from 'node:os';
-import { createExecutor, ExecutorOptions, ExecutorReport } from './executor.js';
-import { MaybePromise, StepFn, SetupFn, TeardownFn, FeedFn, ReportType, ReportTypeList, DEFAULT_CYCLES } from './types.js';
-
-export const DEFAULT_WORKERS = cpus().length;
-
-export const AsyncFunction = (async () => {}).constructor;
-
-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 const DEFAULT_REPORT_TYPES = ['ops'] as const;
-export type DefaultReportTypes = (typeof DEFAULT_REPORT_TYPES)[number];
-
-export class MeasureContext<TContext, TInput> {
-  public pre?: StepFn<TContext, TInput>;
-  public post?: StepFn<TContext, TInput>;
-
-  constructor(
-    public title: string,
-    public run: StepFn<TContext, TInput>,
-  ) {}
-}
-
-export class Measure<TContext, TInput> {
-  #ctx: MeasureContext<TContext, TInput>;
-
-  constructor(ctx: MeasureContext<TContext, TInput>) {
-    this.#ctx = ctx;
-  }
-
-  pre(fn: StepFn<TContext, TInput>): Measure<TContext, TInput> {
-    this.#ctx.pre = fn;
-    return this;
-  }
-  post(fn: StepFn<TContext, TInput>): Measure<TContext, TInput> {
-    this.#ctx.post = fn;
-    return this;
-  }
-}
-
-export class TargetContext<TContext, TInput> {
-  public teardown?: TeardownFn<TContext>;
-  public measures: MeasureContext<TContext, TInput>[] = [];
-
-  constructor(
-    readonly title: string,
-    readonly setup?: SetupFn<MaybePromise<TContext>>,
-  ) {}
-}
-
-export class Target<TContext, TInput> {
-  #ctx: TargetContext<TContext, TInput>;
-
-  constructor(ctx: TargetContext<TContext, TInput>) {
-    this.#ctx = ctx;
-  }
-  teardown(fn: TeardownFn<TContext>): Target<TContext, TInput> {
-    this.#ctx.teardown = fn;
-
-    return this;
-  }
-  measure(title: string, run: StepFn<TContext, TInput>): Measure<TContext, TInput> {
-    const measure = new MeasureContext(title, run);
-    this.#ctx.measures.push(measure);
-
-    return new Measure(measure);
-  }
-}
-
-export class FeedContext<TInput> {
-  constructor(
-    readonly title: string,
-    readonly fn?: FeedFn<TInput>,
-  ) {}
-}
-
-export class Benchmark<TInput> {
-  #targets: TargetContext<unknown, TInput>[] = [];
-  #feeds: FeedContext<TInput>[] = [];
-  #executed = false;
-
-  static create(title: string): Benchmark<void>;
-  static create<I>(title: string, fn: FeedFn<I>): Benchmark<I>;
-  static create<I>(title: string, fn?: FeedFn<I> | undefined): Benchmark<I> {
-    if (fn) {
-      return new Benchmark(title, fn);
-    } else {
-      return new Benchmark(title);
-    }
-  }
-
-  constructor(title: string);
-  constructor(title: string, fn: FeedFn<TInput>);
-  constructor(title: string, fn?: FeedFn<TInput> | undefined) {
-    if (fn) {
-      this.feed(title, fn);
-    } else {
-      this.feed(title);
-    }
-  }
-
-  feed(title: string): Benchmark<TInput | void>;
-  feed<I>(title: string, fn: FeedFn<I>): Benchmark<TInput | I>;
-  feed<I>(title: string, fn?: FeedFn<I> | undefined): Benchmark<TInput | I> {
-    const self = this as Benchmark<TInput | I>;
-    self.#feeds.push(fn ? new FeedContext(title, fn) : new FeedContext(title));
-
-    return self;
-  }
-
-  target<TContext>(title: string): Target<void, TInput>;
-  target<TContext>(title: string, setup: SetupFn<Awaited<TContext>>): Target<TContext, TInput>;
-  target<TContext>(title: string, setup?: SetupFn<Awaited<TContext>> | undefined): Target<TContext, TInput> {
-    const target = new TargetContext<TContext, TInput>(title, setup);
-    this.#targets.push(target as TargetContext<unknown, TInput>);
-
-    return new Target<TContext, TInput>(target);
-  }
-
-  async execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>({
-    workers = DEFAULT_WORKERS,
-    warmupCycles = 20,
-    maxCycles = DEFAULT_CYCLES,
-    minCycles = 50,
-    absThreshold = 1_000,
-    relThreshold = 0.02,
-    reportTypes = DEFAULT_REPORT_TYPES as unknown as R,
-  }: ExecutorOptions<R>): Promise<TargetReport<R>[]> {
-    if (this.#executed) {
-      throw new Error("Benchmark is executed and can't be reused");
-    }
-    this.#executed = true;
-
-    const executor = createExecutor<unknown, TInput, R>({
-      workers,
-      warmupCycles,
-      maxCycles,
-      minCycles,
-      absThreshold,
-      relThreshold,
-      reportTypes,
-    });
-
-    const reports: TargetReport<R>[] = [];
-    for (const target of this.#targets) {
-      const targetReport: TargetReport<R> = { target: target.title, measures: [] };
-      for (const measure of target.measures) {
-        const measureReport: MeasureReport<R> = { measure: measure.title, feeds: [] };
-        for (const feed of this.#feeds) {
-          const data = await feed.fn?.();
-          executor
-            .push<ExecutorReport<R>>({
-              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;
-  }
-}
-
-export const printSimpleReports = <R extends ReportTypeList>(reports: TargetReport<R>[]) => {
-  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();
-    }
-  }
-};
-
-export const printTableReports = <R extends ReportTypeList>(reports: TargetReport<R>[]) => {
-  for (const report of reports) {
-    for (const { measure, feeds } of report.measures) {
-      console.log('\n', report.target, measure);
-      const table: Record<string, unknown> = {};
-      for (const { feed, data } of feeds) {
-        table[feed] = Object.fromEntries(Object.entries(data).map(([key, report]) => [key, report.toString()]));
-      }
-      console.table(table);
-    }
-  }
-};
-
-export const printJSONReports = <R extends ReportTypeList>(reports: TargetReport<R>[], padding?: number) => {
-  const output = {} as Record<string, Record<string, Record<string, string>>>;
-  for (const report of reports) {
-    for (const { measure, feeds } of report.measures) {
-      const row = {} as Record<string, Record<string, string>>;
-      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));
-};