@riim/bench 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Dmitry Vibe <riim@yandex.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/benchmarks/loops.bench.ts

@@ -0,0 +1,75 @@
+import { Bench } from '../src';
+
+const arr = Array.from({ length: 1000 }, (_, idx) => idx + 1);
+let item: number;
+
+const bench = new Bench({ time: 1000 });
+
+bench
+	.add('by index with l-var', () => {
+		for (let i = 0, l = arr.length; i < l; i++) {
+			item = arr[i];
+		}
+	})
+	.add('by index without l-var', () => {
+		for (let i = 0; i < arr.length; i++) {
+			item = arr[i];
+		}
+	})
+	.add('by index without l-var 2', () => {
+		for (let i = 0; i != arr.length; i++) {
+			item = arr[i];
+		}
+	})
+	.add('by index from end', () => {
+		for (let i = arr.length; i != 0; ) {
+			item = arr[--i];
+		}
+	})
+	.add('by index from end 2', () => {
+		for (let i = arr.length - 1; i >= 0; i--) {
+			item = arr[i];
+		}
+	})
+	.add('of operator', () => {
+		for (let item_ of arr) {
+			item = item_;
+		}
+	})
+	.add('Array#forEach()', () => {
+		arr.forEach((item_) => {
+			item = item_;
+		});
+	});
+
+(async () => {
+	await bench.run();
+
+	// ┌──────────────────────────┬─────┬──────────┬──────────┐
+	// │ (index)                  │ pos │ mean     │ rme      │
+	// ├──────────────────────────┼─────┼──────────┼──────────┤
+	// │ by index with l-var      │ 100 │ 0.001055 │ '±0.52%' │
+	// │ by index without l-var   │ 100 │ 0.001057 │ '±1.22%' │
+	// │ Array#forEach()          │ 87  │ 0.001217 │ '±1.74%' │
+	// │ by index without l-var 2 │ 72  │ 0.001458 │ '±0.4%'  │
+	// │ by index from end 2      │ 72  │ 0.001461 │ '±0.3%'  │
+	// │ of operator              │ 68  │ 0.001544 │ '±0.37%' │
+	// │ by index from end        │ 58  │ 0.001833 │ '±0.42%' │
+	// └──────────────────────────┴─────┴──────────┴──────────┘
+	console.table(bench.table());
+
+	await bench.run({ memoryUsage: true });
+
+	// ┌──────────────────────────┬─────┬─────┬──────┬──────┐
+	// │ (index)                  │ pos │ min │ max  │ mean │
+	// ├──────────────────────────┼─────┼─────┼──────┼──────┤
+	// │ by index with l-var      │ 100 │ 448 │ 600  │ 448  │
+	// │ by index without l-var   │ 100 │ 448 │ 3880 │ 448  │
+	// │ by index without l-var 2 │ 100 │ 448 │ 3848 │ 448  │
+	// │ by index from end        │ 100 │ 448 │ 3848 │ 448  │
+	// │ by index from end 2      │ 100 │ 448 │ 3848 │ 448  │
+	// │ of operator              │ 100 │ 448 │ 4080 │ 448  │
+	// │ Array#forEach()          │ 89  │ 504 │ 4032 │ 504  │
+	// └──────────────────────────┴─────┴─────┴──────┴──────┘
+	console.table(bench.memoryUsageTable());
+})();

package/dist/Bench.d.ts

@@ -0,0 +1,63 @@
+export interface ITaskFnParams {
+    timeStart: () => void;
+    timeEnd: () => void;
+}
+export type TTaskFn = (params: ITaskFnParams) => any;
+export interface ITask {
+    name: string;
+    fn: TTaskFn;
+    completionTimeMeasurements: Array<number>;
+    memoryUsageMeasurements: Array<number>;
+}
+export type TReturnedValue = [taskName: string, returnedValue: any];
+export type TCheckReturnedValues = (returnedValues: Array<TReturnedValue>) => void;
+export declare class Bench {
+    readonly name: string | undefined;
+    readonly warmupTime: number;
+    readonly warmupIterations: number;
+    readonly time: number;
+    readonly iterations: number;
+    readonly memoryUsage: boolean;
+    readonly checkReturnedValues: TCheckReturnedValues | null;
+    protected _tasks: Map<string, ITask>;
+    onIterationStart: import("@riim/event").IUnparametrizedEvent<any>;
+    onIterationEnd: import("@riim/event").IUnparametrizedEvent<any>;
+    constructor({ name, warmupTime, warmupIterations, time, iterations, memoryUsage, checkReturnedValues }?: {
+        name?: string;
+        warmupTime?: number;
+        warmupIterations?: number;
+        time?: number;
+        iterations?: number;
+        memoryUsage?: boolean;
+        checkReturnedValues?: TCheckReturnedValues;
+    });
+    add(name: string, fn: TTaskFn): this;
+    remove(name: string): this;
+    run(options?: {
+        warmupTime?: number;
+        warmupIterations?: number;
+        time?: number;
+        iterations?: number;
+        memoryUsage?: boolean;
+        checkReturnedValues?: TCheckReturnedValues;
+    }): Promise<void>;
+    protected _formatMeasurements({ verbose, memoryUsage }?: {
+        verbose?: boolean;
+        memoryUsage?: boolean;
+    }): [taskName: string, taskMeasurements: {
+        hz?: number;
+        min?: number;
+        max?: number;
+        mean: number;
+        avg?: number;
+        p80?: number;
+        p95?: number;
+        p99?: number;
+        p999?: number;
+        rme?: number;
+    }][];
+    table({ verbose }?: {
+        verbose?: boolean;
+    }): Record<string, Record<string, any>>;
+    memoryUsageTable(): Record<string, Record<string, any>>;
+}

package/dist/bench.js

@@ -0,0 +1,242 @@
+import { event, fireEvent } from "@riim/event";
+import jstat from "jstat";
+
+//#region src/utils.ts
+var noop = () => {};
+function round(num, precision, direction = "round") {
+  if (precision === null) return num;
+  precision = Math.pow(10, precision);
+  num *= precision;
+  return (direction == "round" ? Math.round(num) : direction == "floor" ? Math.floor(num) : Math.ceil(num)) / precision;
+}
+function commasify(num, comma = ",") {
+  return num.toString().replace(/(\d)(?=(?:\d{3})+(\.\d*)?(?:\D|$))/g, `$1${comma}`);
+}
+function mean(sortedMeasurements) {
+  var half = sortedMeasurements.length / 2;
+  if (sortedMeasurements.length % 2 == 0) return (sortedMeasurements[half - 1] + sortedMeasurements[half]) / 2;
+  return sortedMeasurements[Math.trunc(half)];
+}
+function percentile(sortedMeasurements, pct) {
+  return sortedMeasurements[Math.round((sortedMeasurements.length - 1) * (pct / 100))];
+}
+function rme(measurements, meanValue) {
+  var n = measurements.length;
+  var tValue = jstat.studentt.inv(.975, n - 1);
+  var variance = measurements.map(val => Math.pow(val - meanValue, 2)).reduce((sum, val) => sum + val, 0) / (n - 1);
+  return tValue * (Math.sqrt(variance) / Math.sqrt(n)) / meanValue * 100;
+}
+
+//#endregion
+//#region src/Bench.ts
+var Bench = class {
+  constructor({
+    name,
+    warmupTime = Infinity,
+    warmupIterations = Infinity,
+    time = Infinity,
+    iterations = Infinity,
+    memoryUsage = false,
+    checkReturnedValues
+  } = {}) {
+    this._tasks = /* @__PURE__ */new Map();
+    this.onIterationStart = event();
+    this.onIterationEnd = event();
+    this.name = name;
+    this.warmupTime = warmupTime;
+    this.warmupIterations = warmupIterations;
+    this.time = time;
+    this.iterations = iterations;
+    this.memoryUsage = memoryUsage;
+    this.checkReturnedValues = checkReturnedValues ?? null;
+  }
+  add(name, fn) {
+    this._tasks.set(name, {
+      name,
+      fn,
+      completionTimeMeasurements: [],
+      memoryUsageMeasurements: []
+    });
+    return this;
+  }
+  remove(name) {
+    this._tasks.delete(name);
+    return this;
+  }
+  async run(options) {
+    var {
+      warmupTime = this.warmupTime,
+      warmupIterations = this.warmupIterations,
+      time = this.time,
+      iterations = this.iterations,
+      memoryUsage = this.memoryUsage,
+      checkReturnedValues = this.checkReturnedValues
+    } = options ?? this;
+    if (warmupTime < 1) throw RangeError("WarmupTime cannot be less than 1");
+    if (warmupIterations < 1) throw RangeError("WarmupIterations cannot be less than 1");
+    if (time == Infinity && iterations === Infinity) throw TypeError("Time or iterations is required");
+    if (time < 1) throw RangeError("Time cannot be less than 1");
+    if (iterations < 1) throw RangeError("Iterations cannot be less than 1");
+    var tasks = [...this._tasks.values()];
+    for (var task of tasks) {
+      task.completionTimeMeasurements.length = 0;
+      task.memoryUsageMeasurements.length = 0;
+    }
+    if (warmupTime != Infinity || warmupIterations != Infinity) {
+      var _taskFnParams = {
+        timeStart: noop,
+        timeEnd: noop
+      };
+      for (var i = 0, startTime = Date.now();; i++) {
+        fireEvent(this.onIterationStart);
+        for (var j = 0, k = tasks.length; j < k; j++) {
+          var returnedValue = tasks[j].fn(_taskFnParams);
+          if (returnedValue instanceof Promise) await returnedValue;
+        }
+        fireEvent(this.onIterationEnd);
+        if (Date.now() - startTime >= warmupTime || i >= warmupIterations) break;
+      }
+    }
+    var taskStartTime;
+    var taskEndTime;
+    var taskFnParams = {
+      timeStart: () => {
+        taskStartTime = performance.now();
+      },
+      timeEnd: () => {
+        taskEndTime = performance.now();
+      }
+    };
+    for (var _i = 0, _startTime = Date.now();; _i++) {
+      tasks.sort(() => Math.random() - .5);
+      var returnedValues = checkReturnedValues ? [] : null;
+      fireEvent(this.onIterationStart);
+      for (var _j = 0, m = tasks.length; _j < m; _j++) {
+        var {
+          name,
+          fn,
+          completionTimeMeasurements,
+          memoryUsageMeasurements
+        } = tasks[_j];
+        var heapUsed = void 0;
+        if (memoryUsage) {
+          gc();
+          ({
+            heapUsed
+          } = process.memoryUsage());
+        }
+        taskStartTime = performance.now();
+        taskEndTime = void 0;
+        var _returnedValue = fn(taskFnParams);
+        if (_returnedValue instanceof Promise) _returnedValue = await _returnedValue;
+        taskEndTime ??= performance.now();
+        if (memoryUsage) {
+          memoryUsageMeasurements.push(process.memoryUsage().heapUsed - heapUsed);
+          gc();
+        }
+        completionTimeMeasurements.push(taskEndTime - taskStartTime);
+        returnedValues?.push([name, _returnedValue]);
+      }
+      checkReturnedValues?.(returnedValues);
+      fireEvent(this.onIterationEnd);
+      if (Date.now() - _startTime >= time || _i >= iterations) break;
+    }
+  }
+  _formatMeasurements({
+    verbose = false,
+    memoryUsage = false
+  } = {}) {
+    return [...this._tasks.values()].reduce((measurements, task) => {
+      var taskMeasurements = memoryUsage ? task.memoryUsageMeasurements : task.completionTimeMeasurements;
+      var sortedTaskMeasurements = taskMeasurements.slice().sort((a, b) => a - b);
+      var sum = 0;
+      for (var i = 0, l = sortedTaskMeasurements.length; i < l; i++) sum += sortedTaskMeasurements[i];
+      var meanValue = mean(sortedTaskMeasurements);
+      measurements.push([task.name, memoryUsage ? {
+        min: sortedTaskMeasurements[0],
+        max: sortedTaskMeasurements.at(-1),
+        mean: meanValue
+      } : verbose ? {
+        hz: taskMeasurements.length / sum * 1e3,
+        min: sortedTaskMeasurements[0],
+        max: sortedTaskMeasurements.at(-1),
+        mean: meanValue,
+        avg: sum / taskMeasurements.length,
+        p80: percentile(sortedTaskMeasurements, 80),
+        p95: percentile(sortedTaskMeasurements, 95),
+        p99: percentile(sortedTaskMeasurements, 99),
+        p999: percentile(sortedTaskMeasurements, 99.9),
+        rme: rme(sortedTaskMeasurements, meanValue)
+      } : {
+        mean: meanValue,
+        rme: rme(sortedTaskMeasurements, meanValue)
+      }]);
+      return measurements;
+    }, []).sort(([, {
+      mean: a
+    }], [, {
+      mean: b
+    }]) => a - b);
+  }
+  table({
+    verbose = false
+  } = {}) {
+    var formattedMeasurements = this._formatMeasurements({
+      verbose
+    });
+    var fastestMean = formattedMeasurements[0][1].mean;
+    return formattedMeasurements.reduce((tabularData, [name, {
+      hz,
+      min,
+      max,
+      mean,
+      avg,
+      p80,
+      p95,
+      p99,
+      p999,
+      rme
+    }]) => {
+      tabularData[name] = {
+        pos: +(fastestMean / mean * 100).toFixed(0),
+        ...(verbose ? {
+          hz: commasify(Math.round(hz)),
+          min: round(min, 4),
+          max: round(max, 4),
+          mean: round(mean, 4),
+          avg: round(avg, 4),
+          p80: round(p80, 4),
+          p95: round(p95, 4),
+          p99: round(p99, 4),
+          p999: round(p999, 4)
+        } : {
+          mean: round(mean, 6)
+        }),
+        rme: `±${round(rme, 2)}%`
+      };
+      return tabularData;
+    }, {});
+  }
+  memoryUsageTable() {
+    var formattedMeasurements = this._formatMeasurements({
+      memoryUsage: true
+    });
+    var fastestMean = formattedMeasurements[0][1].mean;
+    return formattedMeasurements.reduce((tabularData, [name, {
+      min,
+      max,
+      mean
+    }]) => {
+      tabularData[name] = {
+        pos: +(fastestMean / mean * 100).toFixed(0),
+        min: round(min, 4),
+        max: round(max, 4),
+        mean: round(mean, 4)
+      };
+      return tabularData;
+    }, {});
+  }
+};
+
+//#endregion
+export { Bench };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { Bench } from './Bench';

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const noop: () => void;
+export declare function round(num: number, precision: number | null, direction?: 'round' | 'floor' | 'ceil'): number;
+export declare function commasify(num: number | string, comma?: string): string;
+export declare function mean(sortedMeasurements: Array<number>): number;
+export declare function percentile(sortedMeasurements: Array<number>, pct: number): number;
+export declare function rme(measurements: Array<number>, meanValue: number): number;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@riim/bench",
+  "version": "0.1.0",
+  "description": "",
+  "homepage": "https://github.com/Riim/bench#readme",
+  "bugs": {
+    "url": "https://github.com/Riim/bench/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Riim/bench.git"
+  },
+  "license": "MIT",
+  "author": "Dmitry Vibe",
+  "type": "commonjs",
+  "main": "dist/bench.js",
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "build": "rm -rf dist && npx tsc && rolldown -c && babel dist --out-dir dist",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.28.6",
+    "@babel/core": "7.29.0",
+    "@babel/plugin-transform-block-scoping": "7.28.6",
+    "@eslint/js": "9.39.2",
+    "@trivago/prettier-plugin-sort-imports": "6.0.2",
+    "@types/node": "25.2.3",
+    "@typescript-eslint/parser": "8.55.0",
+    "eslint": "9.39.2",
+    "eslint-plugin-github": "6.0.0",
+    "globals": "17.3.0",
+    "rolldown": "1.0.0-rc.4",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.55.0"
+  },
+  "dependencies": {
+    "@riim/event": "0.1.0",
+    "jstat": "1.9.6"
+  }
+}