\n\n[![npm package][npm-img]][npm-url]\n[![Build Status][build-img]][build-url]\n[![Downloads][downloads-img]][downloads-url]\n[![Issues][issues-img]][issues-url]\n\nThe `bench-node` module allows you to measure operations per second of Node.js code blocks.\n\n## Install\n\n```bash\n$ npm install bench-node\n```\n\n## Usage\n\n```cjs\nconst { Suite } = require('bench-node');\n\nconst suite = new Suite();\n\nsuite.add('Using delete property', () => {\n const data = { x: 1, y: 2, z: 3 };\n delete data.y;\n\n data.x;\n data.y;\n data.z;\n});\n\nsuite.run()\n```\n\n```bash\n$ node --allow-natives-syntax my-benchmark.js\nUsing delete property x 3,326,913 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(0ns ... 0ns) p75=0ns p99=0ns\n```\n\nThis module uses V8 deoptimization to help ensure that the code block is not optimized away, producing accurate benchmarks -- but not realistic.\nSee the [Writing JavaScript Microbenchmark Mistakes](#writing-javascript-mistakes) section for more details.\n\nThe [`bench-node-cli`](https://github.com/RafaelGSS/bench-node-cli) tool allows you to execute a `bench-node` benchmark\nfrom any location, eliminating the need to install the `bench-node` package locally.\nSimply use the following command to run your benchmark:\n\n```bash\nnpx bench-node-cli my-benchmark.js\n```\n\nSee the [examples folder](./examples/) for more common usage examples.\n\n## Table of Contents\n\n- [Install](#install)\n- [Usage](#usage)\n- [Table of Contents](#table-of-contents)\n- [Sponsors](#sponsors)\n- [Class: `Suite`](#class-suite)\n - [`new Suite([options])`](#new-suiteoptions)\n - [`suite.add(name[, options], fn)`](#suiteaddname-options-fn)\n - [`suite.run()`](#suiterun)\n- [Dead Code Elimination Detection](#dead-code-elimination-detection)\n - [How It Works](#how-it-works)\n - [Configuration](#configuration)\n - [When DCE Warnings Appear](#when-dce-warnings-appear)\n- [Plugins](#plugins)\n - [Plugin Methods](#plugin-methods)\n - [Example Plugin](#example-plugin)\n- [Using Reporter](#using-reporter)\n - [`textReport` (Default)](#textreport-default)\n - [`chartReport`](#chartreport)\n - [`htmlReport`](#htmlreport)\n - [`jsonReport`](#jsonreport)\n - [CSV Reporter](#csv-reporter)\n - [Pretty Reporter](#pretty-reporter)\n - [Custom Reporter](#custom-reporter)\n- [Setup and Teardown](#setup-and-teardown)\n - [Managed Benchmarks](#managed-benchmarks)\n - [Worker Threads](#worker-threads)\n- [Benchmark Modes](#benchmark-modes)\n - [Operations Mode](#operations-mode)\n - [Time Mode](#time-mode)\n- [Baseline Comparisons](#baseline-comparisons)\n- [Statistical Significance Testing](#statistical-significance-testing-t-test)\n - [Direct API Usage](#direct-api-usage)\n - [Fixing Inconclusive Tests](#fixing-inconclusive-tests)\n- [Writing JavaScript Mistakes](#writing-javascript-mistakes)\n\n## Sponsors\n\nTest machines are generously sponsored by [NodeSource](https://nodesource.com/). \n\n\n## Class: `Suite`\n\n> Stability: 1.1 Active Development\n\nA `Suite` manages and executes benchmark functions. It provides two methods: `add()` and `run()`.\n\n### `new Suite([options])`\n\n* `options` {Object} Configuration options for the suite.\n * `reporter` {Function} Callback function for reporting results. Receives two arguments:\n * `results` {Object[]} Array of benchmark results:\n * `name` {string} Benchmark name.\n * `opsSec` {string} Operations per second.\n * `iterations` {Number} Number of iterations.\n * `histogram` {Histogram} Histogram instance.\n * `ttest` {boolean} Enable Welch's t-test for statistical significance testing. Automatically sets `repeatSuite=30`. **Default:** `false`.\n * `reporterOptions` {Object} Reporter-specific options.\n * `printHeader` {boolean} Whether to print system information header. **Default:** `true`.\n * `labelWidth` {number} Width for benchmark labels in output. **Default:** `45`.\n * `alpha` {number} Significance level for t-test (e.g., 0.05 for 95% confidence). **Default:** `0.05`.\n * `benchmarkMode` {string} Benchmark mode to use. Can be 'ops' or 'time'. **Default:** `'ops'`.\n * `'ops'` - Measures operations per second (traditional benchmarking).\n * `'time'` - Measures actual execution time for a single run.\n * `useWorkers` {boolean} Whether to run benchmarks in worker threads. **Default:** `false`.\n * `plugins` {Array} Array of plugin instances to use.\n * `repeatSuite` {number} Number of times to repeat each benchmark. Automatically set to `30` when `ttest: true`. **Default:** `1`.\n * `plugins` {Array} Array of plugin instances to use. **Default:** `[V8NeverOptimizePlugin]`.\n * `minSamples` {number} Minimum number of samples per round for all benchmarks in the suite. Can be overridden per benchmark. **Default:** `10` samples.\n * `detectDeadCodeElimination` {boolean} Enable dead code elimination detection. When enabled, default plugins are disabled to allow V8 optimizations. **Default:** `false`.\n * `dceThreshold` {number} Threshold multiplier for DCE detection. Benchmarks faster than baseline × threshold will trigger warnings. **Default:** `10`.\n\nIf no `reporter` is provided, results are printed to the console.\n\n```js\nconst { Suite } = require('bench-node');\nconst suite = new Suite();\n```\n\nIf you don't want results to be printed to the console, `false` and `null` can be used\n\n```js\nconst { Suite } = require('bench-node');\nconst suite = new Suite({ reporter: false });\n```\n\n### `suite.add(name[, options], fn)`\n\n* `name` {string} The name of the benchmark, displayed when reporting results.\n* `options` {Object} Configuration options for the benchmark. Supported properties:\n * `minTime` {number} The minimum duration of each sampling interval. **Default:** `0.05` seconds.\n * `maxTime` {number} Maximum duration for the benchmark to run. **Default:** `0.5` seconds.\n * `repeatSuite` {number} Number of times to repeat benchmark to run. **Default:** `1` times.\n * `minSamples` {number} Number minimum of samples the each round. **Default:** `10` samples.\n * `baseline` {boolean} Mark this benchmark as the baseline for comparison. Only one benchmark per suite can be baseline. **Default:** `false`.\n* `fn` {Function|AsyncFunction} The benchmark function. Can be synchronous or asynchronous. \n* Returns: {Suite}\n\nAdds a benchmark function to the suite.\n\n```bash\n$ node --allow-natives-syntax my-benchmark.js\nUsing delete property x 5,853,505 ops/sec (10 runs sampled) min..max=(169ns ... 171ns)\n```\n\n### `suite.run()`\n\n* Returns: `{Promise>}` An array of benchmark results, each containing:\n * `opsSec` {number} Operations per second (Only in 'ops' mode).\n * `opsSecPerRun` {Array} Array of operations per second (useful when repeatSuite > 1).\n * `totalTime` {number} Total execution time in seconds (Only in 'time' mode).\n * `iterations` {number} Number of executions of `fn`.\n * `histogram` {Histogram} Histogram of benchmark iterations.\n * `name` {string} Benchmark name.\n * `plugins` {Object} Object with plugin results if any plugins are active.\n\nRuns all added benchmarks and returns the results.\n\n## Dead Code Elimination Detection\n\n**bench-node** includes optional detection of dead code elimination (DCE) to help identify benchmarks that may be producing inaccurate results. When the JIT compiler optimizes away your benchmark code, it can run nearly as fast as an empty function, leading to misleading performance measurements.\n\n**Important:** DCE detection is **opt-in**. When enabled, the `V8NeverOptimizePlugin` is automatically disabled to allow V8 optimizations to occur naturally. This helps catch benchmarks that would be optimized away in real-world scenarios.\n\n### How It Works\n\nWhen enabled, bench-node measures a baseline (empty function) performance before running your benchmarks. After each benchmark completes, it compares the timing against this baseline. If a benchmark runs suspiciously fast (less than 10× slower than the baseline by default), a warning is emitted.\n\n### Example Warning Output\n\n```\n⚠️ Dead Code Elimination Warnings:\nThe following benchmarks may have been optimized away by the JIT compiler:\n\n • array creation\n Benchmark: 3.98ns/iter\n Baseline: 0.77ns/iter \n Ratio: 5.18x of baseline\n Suggestion: Ensure the result is used or assign to a variable\n\nℹ️ These benchmarks are running nearly as fast as an empty function,\n which suggests the JIT may have eliminated the actual work.\n```\n\n### Configuration\n\n```js\nconst { Suite, V8NeverOptimizePlugin } = require('bench-node');\n\n// Enable DCE detection (disables V8NeverOptimizePlugin automatically)\nconst suite = new Suite({\n detectDeadCodeElimination: true\n});\n\n// Enable DCE detection with custom threshold (default is 10x)\nconst strictSuite = new Suite({\n detectDeadCodeElimination: true,\n dceThreshold: 20 // Only warn if < 20x slower than baseline\n});\n\n// Use both DCE detection AND prevent optimization\n// (helpful for educational purposes to see warnings even when using %NeverOptimizeFunction)\nconst educationalSuite = new Suite({\n plugins: [new V8NeverOptimizePlugin()],\n detectDeadCodeElimination: true\n});\n```\n\n### When DCE Warnings Appear\n\nCommon scenarios that trigger warnings:\n\n```js\n// ❌ Result not used - will be optimized away\nsuite.add('computation', () => {\n const result = Math.sqrt(144);\n // result is never used\n});\n\n// ✅ Result is used - less likely to be optimized\nsuite.add('computation', () => {\n const result = Math.sqrt(144);\n if (result !== 12) throw new Error('Unexpected');\n});\n```\n\n**Note:** DCE detection only works in `'ops'` benchmark mode and when not using worker threads. It is automatically disabled for `'time'` mode and worker-based benchmarks.\n\nSee [examples/dce-detection/](./examples/dce-detection/) for more examples.\n\n## Plugins\n\nPlugins extend the functionality of the benchmark module. \n\nSee [Plugins](./doc/Plugins.md) for details.\n\n### Plugin Methods\n\n- **`isSupported()`**: Checks if the plugin can run in the current environment.\n- **`beforeClockTemplate(varNames)`**: Injects code before the benchmark starts. Returns an array with:\n * `Code` {string} JavaScript code to execute.\n * `Wrapper` {string} (optional) Function to wrap the benchmark function.\n- **`afterClockTemplate(varNames)`**: Injects code after the benchmark finishes. Returns an array with:\n * `Code` {string} JavaScript code to execute.\n- **`onCompleteBenchmark(result, bench)`**: Called when the benchmark completes, allowing plugins to process results.\n- **`toString()`**: Returns a string identifier for the plugin.\n- **`getReport(benchmarkName)`**: Returns a string to be displayed in the benchmark result line.\n- **`getResult(benchmarkName)`**: Returns the data that can be used by the reporter.\n- **`reset()`**: Resets the plugin state, to avoid carrying over data between benchmarks.\n\n### Example Plugin\n\n```js\nclass V8OptimizeOnNextCallPlugin {\n isSupported() {\n try {\n new Function(`%OptimizeFunctionOnNextCall(() => {})`)();\n return true;\n } catch (e) {\n return false;\n }\n }\n\n beforeClockTemplate({ awaitOrEmpty, bench }) {\n let code = '';\n code += `%OptimizeFunctionOnNextCall(${bench}.fn);\\n`;\n code += `${awaitOrEmpty}${bench}.fn();\\n`;\n code += `${awaitOrEmpty}${bench}.fn();\\n`;\n return [code];\n }\n\n toString() {\n return 'V8OptimizeOnNextCallPlugin';\n }\n}\n```\n\n## Using Reporter\n\nThis module exports two reporters that control how benchmark results are displayed:\na detailed `textReport` for statistical analysis, and a visual `chartReport` that\ndisplays a bar graph in the terminal.\n\n### `textReport` (Default)\n\nThe `textReport` is the default reporter, which provides simple statistical information\nabout each benchmark result. It includes the number of operations per second, the number\nof runs sampled, min...max, and enabled plugins.\n\n**Example Output**:\n\n```\nsingle with matcher x 710,248 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(1.40us...1.42us)\nmultiple replaces x 604,713 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(1.64us...1.70us)\n```\n\nHere’s how you can explicitly pass it as a reporter:\n\n```cjs\nconst { Suite, textReport } = require('bench-node');\n\nconst suite = new Suite({\n reporter: textReport, // Optional, since this is the default\n});\n```\n\n### `chartReport`\n\nThe `chartReport` reporter provides a graphical representation of benchmark\nresults in the form of a bar chart, making it easier to visualize the relative\nperformance of each benchmark. It scales the bars based on the highest operations\nper second (ops/sec) value, and displays the results incrementally as they are collected.\n\nExample output:\n\n```\nNode.js version: v23.6.1\nPlatform: darwin arm64\nCPU Cores: 8 vCPUs | 16.0GB Mem\n\nsingle with matcher | ██████████████████████████████ | 709,321 ops/sec | 10 samples\nmultiple replaces | ██████████████████████████---- | 606,401 ops/sec | 11 samples\n```\n\nUsage:\n\n```cjs\nconst { Suite, chartReport } = require('bench-node');\n\nconst suite = new Suite({\n reporter: chartReport,\n // Optionally control header display\n reporterOptions: {\n printHeader: true // Set to false to hide system info header\n }\n});\n```\n\nThe `reporterOptions.printHeader` setting controls whether the system information (Node.js version, platform, and CPU cores) appears at the top of the output. This is useful when running multiple suites in sequence and you want to avoid duplicate headers.\n\n### `htmlReport`\n\nThe `htmlReport` generates an interactive HTML visualization of benchmark results.\nIt transforms benchmark data into a visual format, such as speed circle animations,\nmaking it easier to interpret and share performance insights.\n\nExample output:\n\nhttps://github.com/user-attachments/assets/b2b98175-6648-4af4-8319-63f3ebbc729e\n\nUsage:\n\n```cjs\nconst { Suite, htmlReport } = require('bench-node');\n\nconst suite = new Suite({\n reporter: htmlReport,\n});\n```\n\n### `jsonReport`\n\nThe `jsonReport` plugin provides benchmark results in **JSON format**. \nIt includes key performance metrics—such as `opsSec`, `runsSampled`, `min`\nand `max` times, and any reporter data from your **plugins**—so you can easily\nstore, parse, or share the information.\n\nExample output:\n\n```json\n[\n {\n \"name\": \"single with matcher\",\n \"opsSec\": 180000,\n \"runsSampled\": 50,\n \"min\": \"13.20μs\",\n \"max\": \"82.57μs\",\n \"plugins\": []\n },\n {\n \"name\": \"Multiple replaces\",\n \"opsSec\": 170000,\n \"runsSampled\": 50,\n \"min\": \"15.31μs\",\n \"max\": \"77.49μs\",\n \"plugins\": []\n }\n]\n```\n\n**Usage:**\n\n```cjs\nconst { Suite, jsonReport } = require('bench-node');\n\nconst suite = new Suite({\n reporter: jsonReport,\n});\n```\n\n### CSV Reporter\n\nThe `csvReport` plugin generates benchmark results in CSV format.\nIt includes columns for key performance metrics like `ops/sec`, `samples`, `min` and `max` times,\nas well as any reporter data provided by your plugins.\n\nExample output:\n\n```csv\nname,ops/sec,samples,plugins,min,max\nUsing delete property,\"7,732,517\",10,v8-never-optimize=true,127.91ns,129.95ns\nUsing delete property (proto: null),\"24,636,631\",10,v8-never-optimize=true,39.57ns,40.91ns\nUsing delete property (cached proto: null),\"7,497,893\",11,v8-never-optimize=true,132.25ns,134.89ns\nUsing undefined assignment,\"132,093,600\",11,v8-never-optimize=true,7.53ns,7.64ns\nUsing undefined assignment (proto: null),\"28,231,374\",9,v8-never-optimize=true,35.27ns,35.42ns\nUsing undefined property (cached proto: null),\"60,843,193\",10,v8-never-optimize=true,16.24ns,16.65ns\n[Managed] Using undefined property (cached proto: null),\"35,394,060\",10,v8-never-optimize=true,27.90ns,28.54ns\n```\n\n**Usage:**\n\n```cjs\nconst { Suite, csvReport } = require('bench-node');\n\nconst suite = new Suite({\n reporter: csvReport,\n});\n```\n\n### Pretty Reporter\n\nThe `prettyReport` provides a beautiful, hierarchical view of your benchmark results.\n\n**Usage:**\n\n```javascript\nconst { Suite } = require('bench-node');\n\n// You can either pass the reporter function directly...\nconst suiteWithReporter = new Suite({\n reporter: prettyReport,\n});\n\n// ...or use the `pretty` option for convenience.\nconst suiteWithPrettyOption = new Suite({\n pretty: true,\n});\n\nsuite\n .add('my-group/my-benchmark', () => {\n //...\n })\n .add('my-group/my-benchmark-2', () => {\n //...\n })\n .add('second-group/baseline', () => {\n //...\n })\n .run();\n```\n\n**Sample Output:**\n\n```\nSystem Information:\n Node.js: v22.15.0\n OS: darwin 24.5.0\n CPU: Apple M2\n\nBenchmark results (3 total):\nPlugins enabled: V8NeverOptimizePlugin\n├─ my-group\n│ ├─ my-benchmark 1,461,380 ops/sec (10 runs sampled) min..max=(682.30ns...685.79ns)\n│ └─ my-benchmark-2 2,270,973 ops/sec (10 runs sampled) min..max=(437.22ns...444.12ns)\n└─ second-group\n └─ baseline 637,787 ops/sec (11 runs sampled) min..max=(1.54us...1.59us)\n```\n\n### Custom Reporter\n\nCustomize data reporting by providing a `reporter` function when creating the `Suite`:\n\n```js\nconst { Suite } = require('bench-node');\n\nfunction reporter(results) {\n for (const result of results) {\n console.log(`Benchmark: ${result.name}`);\n console.log(`Operations per second: ${result.opsSec}`);\n console.log(`Iterations: ${result.iterations}`);\n console.log(`Histogram: ${result.histogram}`);\n }\n}\n\nconst suite = new Suite({ reporter });\n\nsuite.add('Using delete to remove property from object', () => {\n const data = { x: 1, y: 2, z: 3 };\n delete data.y;\n\n data.x;\n data.y;\n data.z;\n});\n\nsuite.run();\n```\n\n```bash\n$ node --allow-natives-syntax my-benchmark.js\nBenchmark: Using delete to remove property from object - 6,032,212 ops/sec\n```\n\n## Setup and Teardown\n\nControl the benchmark function's setup and teardown using the timer argument:\n\n```js\nconst { Suite } = require('bench-node');\nconst { readFileSync, writeFileSync, rmSync } = require('node:fs');\n\nconst suite = new Suite();\n\nsuite.add('readFileSync', (timer) => {\n const randomFile = Date.now();\n const filePath = `./${randomFile}.txt`;\n writeFileSync(filePath, Math.random().toString());\n\n timer.start();\n readFileSync(filePath, 'utf8');\n timer.end();\n\n rmSync(filePath);\n}).run();\n```\n\nFor advanced setups, use the timer argument to start and end timing explicitly:\n\n```js\nconst { Suite } = require('bench-node');\nconst { readFileSync, writeFileSync, rmSync } = require('node:fs');\n\nconst suite = new Suite();\n\nsuite.add('readFileSync', (timer) => {\n const randomFile = Date.now();\n const filePath = `./${randomFile}.txt`;\n writeFileSync(filePath, Math.random().toString());\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n readFileSync(filePath, 'utf8');\n }\n timer.end(timer.count);\n\n rmSync(filePath);\n});\n\nsuite.run();\n```\n\n> [!WARNING]\n> When using the `timer`, the setup will also be deoptimized.\n> As a result, if you compare this approach with one that uses functions outside\n> the benchmark function, the results may not match.\n> See: [Deleting Properties Example](./examples/deleting-properties/node.js).\n\nEnsure you call `.start()` and `.end()` methods when using the timer argument, or an `ERR_BENCHMARK_MISSING_OPERATION` error will be thrown.\n\n### Managed Benchmarks\n\nIn regular benchmarks (when `timer` is not used), you run the benchmarked function in a loop,\nand the timing is managed implicitly.\nThis means each iteration of the benchmarked function is measured directly.\nThe downside is that optimizations like inlining or caching might affect the timing, especially for fast operations.\n\nExample:\n\n```cjs\nsuite.add('Using includes', () => {\n const text = 'text/html,...';\n const r = text.includes('application/json');\n});\n```\n\nHere, `DoNotOptimize` is called inside the generated loop for regular benchmarks\n(assuming `V8NeverOptimizePlugin` is being used), and the benchmark function is\nalso marked with `%NeverOptimizeFunction`.\nTogether, these prevent V8 from optimizing the benchmark function and from\ntreating the returned value as irrelevant.\n\nManaged benchmarks explicitly handle timing through `start()` and `end()` calls around the benchmarked code.\nThis encapsulates the entire set of iterations in one timed block,\nwhich can result in tighter measurement with less overhead.\nHowever, it can lead to over-optimistic results, especially if the timer’s start and stop calls are placed outside of the loop,\nallowing V8 to over-optimize the entire block.\n\nExample:\n\n```cjs\nsuite.add('[Managed] Using includes', (timer) => {\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n const text = 'text/html,...';\n const r = text.includes('application/json');\n assert.ok(r); // Ensure the result is used so it doesn't get V8 optimized away\n }\n timer.end(timer.count);\n});\n```\n\nIn this case, `DoNotOptimize` is applied to the benchmark function's return value,\noutside the user-managed loop. It does not consume the local `r` value from each\niteration. That's why `assert.ok(r)` has been used: it makes the per-iteration\nresult observable inside the timed block.\n\n> [!NOTE]\n> V8 assumptions can change any time soon. Therefore, it's crucial to investigate\n> results between versions of V8/Node.js.\n\n### Worker Threads\n\n> Stability: 1.0 (Experimental)\n\n`bench-node` provides experimental support for **Worker Threads**. When you set `useWorkers: true`,\nthe library runs each benchmark in a separate worker thread, ensuring that one benchmark\ndoes not affect another. Usage is straightforward:\n\n```cjs\nconst suite = new Suite({\n useWorkers: true,\n});\n```\n\n## Benchmark Modes\n\n`bench-node` supports multiple benchmarking modes to measure code performance in different ways.\n\n### Operations Mode\n\nOperations mode (default) measures how many operations can be performed in a given timeframe. \nThis is the traditional benchmarking approach that reports results in operations per second (ops/sec).\n\nThis mode is best for:\n- Comparing relative performance between different implementations\n- Measuring throughput of small, fast operations\n- Traditional microbenchmarking\n\nExample output:\n```\nString concatenation x 12,345,678 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(81ns...85ns)\n```\n\n### Time Mode\n\nTime mode measures the actual time taken to execute a function exactly once. \nThis mode is useful when you want to measure the real execution time for operations that have a known, fixed duration.\n\nThis mode is best for:\n- Costly operations where multiple instructions are executed in a single run \n- Benchmarking operations with predictable timing\n- Verifying performance guarantees for time-sensitive functions\n\nTo use time mode, set the `benchmarkMode` option to `'time'` when creating a Suite:\n\n```js\nconst { Suite } = require('bench-node');\n\nconst timeSuite = new Suite({\n benchmarkMode: 'time' // Enable time mode\n});\n\n// Create a function that takes a predictable amount of time\nconst delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));\n\ntimeSuite.add('Async Delay 100ms', async () => {\n await delay(100);\n});\n\ntimeSuite.add('Sync Busy Wait 50ms', () => {\n const start = Date.now();\n while (Date.now() - start < 50);\n});\n\n// Optional: Run the benchmark multiple times with repeatSuite\ntimeSuite.add('Quick Operation with 5 repeats', { repeatSuite: 5 }, () => {\n // This will run exactly once per repeat (5 times total)\n // and report the average time\n let x = 1 + 1;\n});\n\n(async () => {\n await timeSuite.run();\n})();\n```\n\nIn time mode, results include `totalTime` (in seconds) instead of `opsSec`.\n\nExample output:\n```\nAsync Delay 100ms x 0.1003s (1 sample) v8-never-optimize=true\nSync Busy Wait 50ms x 0.0502s (1 sample) v8-never-optimize=true\nQuick Operation with 5 repeats x 0.0000s (5 samples) v8-never-optimize=true\n```\n\nSee [examples/time-mode.js](./examples/time-mode.js) for a complete example.\n\n## Baseline Comparisons\n\nYou can mark one benchmark as a baseline to compare all other benchmarks against it:\n\n```js\nconst { Suite } = require('bench-node');\n\nconst suite = new Suite();\n\nsuite\n .add('baseline', { baseline: true }, () => {\n // baseline implementation\n const arr = [1, 2, 3];\n arr.includes(2);\n })\n .add('alternative', () => {\n // alternative implementation\n const arr = [1, 2, 3];\n arr.indexOf(2) !== -1;\n });\n\nsuite.run();\n```\n\nExample output with baseline:\n```\nbaseline x 52,832,865 ops/sec (10 runs sampled) min..max=(18.50ns...19.22ns)\nalternative x 53,550,219 ops/sec (11 runs sampled) min..max=(18.26ns...18.89ns)\n\nSummary (vs. baseline):\n baseline (baseline)\n alternative (1.01x faster)\n```\n\n## Statistical Significance Testing (T-Test)\n\n> Stability: 1.0 (Experimental)\n\nWhen comparing benchmarks, especially on machines with high variance (cloud VMs, shared environments),\nraw ops/sec differences may not be meaningful. `bench-node` provides **Welch's t-test** to determine\nif performance differences are statistically significant.\n\nWelch's t-test is preferred over Student's t-test because it doesn't assume equal variances between\nthe two samples, which is common in benchmark scenarios.\n\n### Enabling T-Test Mode\n\nEnable t-test mode with `ttest: true`. This automatically sets `repeatSuite=30` to collect enough\nindependent samples for reliable statistical analysis (per the Central Limit Theorem):\n\n```js\nconst { Suite } = require('bench-node');\n\nconst suite = new Suite({\n ttest: true, // Enables t-test and auto-sets repeatSuite=30\n});\n\nsuite\n .add('baseline', { baseline: true }, () => {\n let sum = 0;\n for (let i = 0; i < 100; i++) sum += i;\n })\n .add('optimized', () => {\n let sum = (99 * 100) / 2; // Gauss formula\n });\n\nsuite.run();\n```\n\nExample output:\n```\nT-Test Mode: Enabled (repeatSuite=30)\n\nbaseline x 1,234,567 ops/sec (300 runs sampled) min..max=(810.05ns...812.45ns)\noptimized x 9,876,543 ops/sec (305 runs sampled) min..max=(101.23ns...102.87ns)\n\nSummary (vs. baseline):\n baseline (baseline)\n optimized (8.00x faster) ***\n\n Significance: * p<0.05, ** p<0.01, *** p<0.001\n```\n\nThe asterisks indicate significance level:\n- `***` = p < 0.001 (0.1% risk of false positive)\n- `**` = p < 0.01 (1% risk of false positive)\n- `*` = p < 0.05 (5% risk of false positive)\n- (no stars) = not statistically significant\n\nThis helps identify when a benchmark shows a difference due to random variance vs. a real performance improvement.\n\n**How it works**: With `ttest: true`, each benchmark runs 30 times independently (via `repeatSuite=30`). The t-test compares the 30 ops/sec values from the baseline against the 30 ops/sec values from each test benchmark. This accounts for run-to-run variance within that benchmark session.\n\n**Note**: Running the entire benchmark suite multiple times may still show variance in absolute numbers due to system-level factors (CPU frequency scaling, thermal throttling, background processes). The t-test helps determine if differences are statistically significant within each benchmark session, but results can vary between separate benchmark runs due to changing system conditions.\n\nSee also: [Fixing Inconclusive Tests](doc/Inconclusive.md).\n\n### Direct API Usage\n\nYou can also use the t-test utilities directly for custom analysis:\n\n```js\nconst { welchTTest, compareBenchmarks } = require('bench-node');\n\n// Raw sample data from two benchmarks (e.g., timing samples in nanoseconds)\nconst baseline = [100, 102, 99, 101, 100, 98, 103, 99, 100, 101];\nconst optimized = [50, 51, 49, 52, 50, 48, 51, 49, 50, 51];\n\n// High-level comparison\nconst result = compareBenchmarks(optimized, baseline, 0.05);\nconsole.log(result);\n// {\n// significant: true,\n// pValue: 0.00001,\n// confidence: '99.99%',\n// stars: '***',\n// difference: 'faster',\n// tStatistic: 45.2,\n// degreesOfFreedom: 17.8\n// }\n\n// Low-level Welch's t-test\nconst ttest = welchTTest(optimized, baseline);\nconsole.log(ttest);\n// {\n// tStatistic: 45.2,\n// degreesOfFreedom: 17.8,\n// pValue: 0.00001,\n// significant: true,\n// mean1: 50.1,\n// mean2: 100.3,\n// variance1: 1.43,\n// variance2: 2.23\n// }\n```\n\n#### Interpreting Results\n\n- **`significant: true`** - The performance difference is statistically significant at the given alpha level\n- **`pValue`** - Probability that the observed difference occurred by chance (lower = more confident)\n- **`confidence`** - Confidence level (e.g., \"99.95%\" means 99.95% confident the difference is real)\n- **`stars`** - Visual indicator of significance: `'***'` (p<0.001), `'**'` (p<0.01), `'*'` (p<0.05), or `''` (not significant)\n- **`difference`** - Whether the first sample is `'faster'`, `'slower'`, or `'same'` as the second\n\nA common threshold is `alpha = 0.05` (95% confidence). If `pValue < alpha`, the difference is significant.\n\n## Writing JavaScript Mistakes\n\nWhen working on JavaScript micro-benchmarks, it’s easy to forget that modern engines use\nmultiple tiers of Just-In-Time (JIT) compilation and sometimes even entirely different\noptimizations. The results you get from a simple timing loop often aren’t representative\nof how your code will behave under real-world conditions, especially once the browser or\nruntime has adjusted for frequent function calls. Caching, tail call optimizations,\nand hidden class transformations can all distort your measurements, leading to overblown\nclaims about performance improvements that might never materialize in production.\n\nThat’s why **bench-node** was created—to provide a stable and consistent way to compare\nsmall snippets of code. By default, it tells V8 to never optimize the benchmark\nfunction with `%NeverOptimizeFunction(bench.fn)` and consumes the returned value\nwith a non-optimized `DoNotOptimize` helper so the JIT compiler doesn’t remove\ndead code. However, even this approach can’t fully replicate real-world scenarios\nin which V8 optimizations and unpredictable workloads impact performance. Think of\nbench-node as a helpful tool for quick comparisons rather than a guarantee of what you’ll\nsee in production.\n\n\n[build-img]:https://github.com/RafaelGSS/bench-node/actions/workflows/release.yml/badge.svg\n\n[build-url]:https://github.com/RafaelGSS/bench-node/actions/workflows/release.yml\n\n[downloads-img]:https://img.shields.io/npm/dt/bench-node\n\n[downloads-url]:https://www.npmtrends.com/bench-node\n\n[npm-img]:https://img.shields.io/npm/v/bench-node\n\n[npm-url]:https://www.npmjs.com/package/bench-node\n\n[issues-img]:https://img.shields.io/github/issues/RafaelGSS/bench-node\n\n[issues-url]:https://github.com/RafaelGSS/bench-node/issues\n"
},
{
"path": "assets/README.md",
"content": "# \"Branding\"\n\n## Logo\n\n| Logo | Description |\n| --- | --- |\n|  | simple logo for readme |\n|  | logo with text for light backgrounds |\n|  | logo with text for dark backgrounds |\n\n## Other\n\n- **Font**: [Geist](https://fonts.google.com/specimen/Geist)\n- **Light Green**: `#84BA64`\n- **Dark Green**: `#2C682C`\n\n> The design of the assets was created by [@AugustinMauroy](https://github.com/AugustinMauroy).\n"
},
{
"path": "biome.json",
"content": "{\n\t\"$schema\": \"https://biomejs.dev/schemas/1.8.3/schema.json\",\n\t\"organizeImports\": {\n\t\t\"enabled\": true\n\t},\n\t\"linter\": {\n\t\t\"enabled\": true,\n\t\t\"rules\": {\n\t\t\t\"recommended\": true,\n\t\t\t\"suspicious\": {\n\t\t\t\t\"noExplicitAny\": \"off\"\n\t\t\t},\n\t\t\t\"style\": {\n\t\t\t\t\"noParameterAssign\": \"off\",\n\t\t\t\t\"noUselessElse\": \"off\"\n\t\t\t}\n\t\t}\n\t},\n\t\"formatter\": {\n\t\t\"enabled\": true\n\t},\n\t\"files\": {\n\t\t\"ignore\": [\n\t\t\t\"examples/*\",\n\t\t\t\"coverage/*\",\n\t\t\t\"test/plugin-api-doc.js\",\n\t\t\t\"package.json\"\n\t\t]\n\t}\n}\n"
},
{
"path": "doc/Inconclusive.md",
"content": "# Fixing Inconclusive Tests\n\nt-tests are looking at the distribution of both sets of results and trying to determine if they overlap in a way that\nmakes the average value significant or just noise in the results. A run with a bimodal distribution for instance, caused\nby problems with the machine the tests are running on or the NodeJS runtime doing things in the background. Here are a\nfew causes.\n\n## Random Input Data\n\nVariability in the inputs between runs can lead to big changes in the runtime of an algorithm. Particularly with code\nthat sorts, filters, or conditionally operates on input data, feeding them certain combinations of data will result in\nwildly different run times from one loop to the next or occasionally from one sample to the next. The Central Limit\nTheorem (that over a long enough time a situation will revert to the mean), does not invalidate the existence of the\nGambler's Paradox (that it will revert to the mean before I become bankrupt).\n\nIt is better to do your fuzzing in fuzz tests and pick representative data for your benchmarks. Partially informed by\nthe results of your fuzz tests, and other bug reports.\n\n## Underprovisioned VM, Oversubscribed hardware\n\nFor a clean micro benchmark, we generally want to be the only one using the machine at the time. There are a number of\nknown issues running benchmarks on machines that are thermally throttling, or on cheap VMs that use best-effort to\nallocate CPU time to the running processes. In particular, docker images with `cpu-shares` are especially poor targets\nfor running benchmarks because the quota might expire for one timeslice in the middle of one test or between benchmarks\nin a single Suite. This creates an unfair advantage for the first test, and/or lots of noise in the results. We are\ncurrently investigating ways to detect this sort of noise, and analyzing if the t-tests are sufficient to do so.\n\n## Epicycles in GC or JIT compilation\n\nIf the warmup time is insufficient to get V8 to optimize the code, it may kick in during the middle of a sample, which\nwill introduce a bimodal distribution of answers (before, and after). There is currently not a way to adjust the warmup\ntime of `bench-node`, but should be added as a feature.\n\nOne of the nastiest performance issues to detect in garbage collected code is allocation epicycles. This happens when\nearly parts of a calculation create lots of temporary data but not sufficient to cross the incremental or full GC\nthreshold, so that the next function in a call sequence routinely gets hit with exceeding the threshold. This is\nespecially common in code that generates a JSON or HTML response to a series of calculations - it is the single biggest\nallocation in the sequence, but it gets blamed in the performance report for the lion's share of the CPU time.\n\nIf you change the `minTime` up or down, that will alter the number of iterations per sample which may smooth out the\nresults. You can also try increasing `minSamples` to get more samples. But also take this as a suggestion that your code\nmay have a performance bug that is worth prioritizing.\n\nForcing GC in the teardown or setup methods between subsequent tests in a single Suite may help with some situations\nwhen reordering the tests results in differences in runtime, but for the more general case, you may need to review the\ncode under test to make it 'play well' both with benchmarking and in production systems.\n\nIn production code, particularly where p9# values are used as a fitness test, it is sometimes better to chose the\nalgorithm with more consistent runtime over the one with supposedly better average runtime. This can also be true where\nDDOS scenarios are possible - the attacker will always chose the worst, most assymetric request to send to your machine,\nand mean response time will not matter one whit. If `bench-node` is complaining, the problem may not be `bench-node`.\n"
},
{
"path": "doc/Plugins.md",
"content": "# Plugins\n\nThe benchmark module supports a flexible plugin system that\nallows you to extend its functionality by adding custom plugins.\nThis documentation explains how to create, validate, and use\nplugins within the benchmarking framework.\n\n[V8NeverOptimizePlugin](#class-v8neveroptimizeplugin) is enabled by default.\n\nTo observe how a plugin is used, see the `plugin-api-doc.js` file in tests and explore its results.\n\n## Structure\n\nEach plugin is expected to follow a specific structure with required methods\nfor integration into the benchmark module. The plugins are required to define\nthe following methods:\n\n* `isSupported()`: This method checks if the plugin can run in the\n current environment. If the plugin uses features specific to certain\n environments (e.g., V8 engine features), it should return `true` if those\n features are available and `false` otherwise.\n\n* `toString()`: This method should return a string representation of the plugin.\n It’s used for logging and error messages.\n\nIn addition to these required methods, plugins can optionally define other\nmethods based on their functionality, such as `beforeClockTemplate()`,\n`afterClockTemplate()`, `onCompleteBenchmark()`, and more.\n\n## Plugin Methods\n\n### `isSupported()` (required)\n\nThis method checks if the plugin's functionality is available in the\ncurrent environment. For instance, if a plugin uses specific V8 engine commands,\nthis method ensures the environment supports them.\n\n### `beforeClockTemplate(varNames)`\n\n* `varNames` {Object}\n * `bench` {string} - Name for the benchmark variable.\n * `context` {string} - Name for the context variable.\n * `timer` {string} - Name for the timer variable.\n * `awaitOrEmpty` {string} - A string with `await` or empty string (`''`).\n\nSome plugins need to modify or prepare the code before the benchmark starts.\nThe `beforeClockTemplate()` method allows you to inject code before the timing\nprocess begins.\n\nThis method must return an array where:\n\n* The first element is a string representing the JavaScript code to be executed\nbefore the benchmark function.\n\n* The second element (optional) is a string representing a function that will\nwrap the benchmark function. This wrapper is used to customize how the\nbenchmark function is called during execution.\n\nThe wrapped function provides a powerful way to manipulate how the benchmark\nis run without directly modifying the benchmark logic.\n\n```js\nbeforeClockTemplate({ bench }) {\n let code = '';\n\n code += `\nfunction DoNotOptimize(x) {}\n// Prevent the benchmark function and result consumer from optimizing or being inlined.\n%NeverOptimizeFunction(${bench}.fn);\n%NeverOptimizeFunction(DoNotOptimize);\n`\n return [code, 'DoNotOptimize'];\n}\n```\n\nIn this example, the plugin injects the `DoNotOptimize` function and also\nprovides it as a wrapper for the benchmark function result. The benchmark\nfunction itself is marked with `%NeverOptimizeFunction(${bench}.fn)`, while the\n`DoNotOptimize` wrapper consumes the returned value so the benchmark expression\ndoes not become observationally irrelevant.\n\nThese two protections address different parts of the generated code:\n`%NeverOptimizeFunction(${bench}.fn)` targets the function under test, and\n`DoNotOptimize(bench.fn())` targets the value returned by each call.\n\n### `afterClockTemplate(varNames)`\n\n* `varNames` {Object}\n * `bench` {string} - Name for the benchmark variable.\n * `context` {string} - Name for the context variable.\n * `timer` {string} - Name for the timer variable.\n * `awaitOrEmpty` {string} - A string with `await` or empty string (`''`).\n\nAfter the benchmark runs, this method can inject code to gather performance data\nor reset configurations. It must return an array where:\n\n* The first element is a string containing the JavaScript code to be executed\nafter the benchmark finishes.\n\nUnlike `beforeClockTemplate`, `afterClockTemplate` does not support a second\nelement in the returned array, as it only runs cleanup or data collection code\nafter the benchmark is executed.\n\n### `onCompleteBenchmark(result)`\n\n* `result` {Object}\n * `duration` {number} - Benchmark duration\n * `count` {number} - Number of iterations\n * `context` {Object} - A object used to store results after the benchmark clock\n\nThis method is called when the benchmark completes. Plugins can collect and\nprocess data from the benchmark results in this step.\n\n### `toString()` (required)\n\nThis method returns a string identifier for the plugin, typically the plugin’s\nname. It is used in error messages and logging.\n\n## Example Plugins\n\nHere are examples of plugins that follow the required structure and functionality.\n\n```js\nclass V8OptimizeOnNextCallPlugin {\n isSupported() {\n try {\n new Function(`%OptimizeFunctionOnNextCall(() => {})`)();\n return true;\n } catch (e) {\n return false;\n }\n }\n\n beforeClockTemplate({ awaitOrEmpty, bench }) {\n let code = '';\n\n code += `%OptimizeFunctionOnNextCall(${ bench }.fn);\\n`;\n code += `${ awaitOrEmpty }${ bench }.fn();\\n`;\n code += `${ awaitOrEmpty }${ bench }.fn();\\n`;\n\n return [code];\n }\n\n toString() {\n return 'V8OptimizeOnNextCallPlugin';\n }\n}\n```\n\n## Official Plugins\n\nThis is a list of official plugins that can be fetched when requiring\n`bench-node` module.\n\n```js\nconst { V8OptimizeOnNextCallPlugin, Suite } = require('bench-node');\nconst suite = new Suite({\n plugins: [new V8OptimizeOnNextCallPlugin()],\n})\n```\n\n### Class: `V8OptimizeOnNextCallPlugin`\n\nThe `V8OptimizeOnNextCallPlugin` triggers the V8 engine to optimize the\nfunction before it is called. This can improve performance in repeated\nbenchmarks.\n\n### Class: `V8NeverOptimizePlugin`\n\nThe `V8NeverOptimizePlugin` prevents the V8 engine from optimizing or inlining\nthe benchmark function. It also wraps the benchmark result in a non-optimized\n`DoNotOptimize` helper so V8 cannot treat an unused return value as irrelevant.\n\n### Class: `V8GetOptimizationStatus`\n\nThe `V8GetOptimizationStatus` plugin collects the V8 engine's optimization\nstatus for a given function after it has been benchmarked.\n"
},
{
"path": "examples/.gitignore",
"content": ""
},
{
"path": "examples/benchmark-comparison/README.md",
"content": "# Benchmark Comparison Framework\n\nThis directory contains a framework for comparing `bench-node` against other popular benchmark libraries:\n\n- [Benchmark.js](https://benchmarkjs.com/)\n- [Mitata](https://github.com/evanwashere/mitata)\n- [Tinybench](https://github.com/tinylibs/tinybench)\n\n## Test Cases\n\nThe comparison focuses on four key test scenarios:\n\n1. **JIT Optimizable** - Simple operations that the JavaScript JIT compiler might optimize away\n2. **Regex Test** - Regular expression pattern matching operations\n3. **Fibonacci** - CPU-bound recursive calculation\n\n## Running the Comparisons\n\nTo run any of the comparison scripts, use:\n\n```bash\nnode --allow-natives-syntax examples/benchmark-comparison/comparison.js\n```\n\n> **Note:** All bench-node scripts must be run with the `--allow-natives-syntax` flag.\n"
},
{
"path": "examples/benchmark-comparison/comparison.js",
"content": "\nconst { Suite } = require('../../lib');\nconst Benchmark = require('benchmark');\nconst { bench, run: mitataRun } = require('mitata');\nconst { Bench } = require('tinybench');\n\nconst testSuites = {\n 'simple-operations': {\n name: 'Simple Operations',\n tests: {\n 'jit-optimizable': {\n name: 'JIT Optimizable',\n fn: function() {\n const x = 1;\n const y = 2;\n return x + y;\n }\n }\n }\n },\n \n 'string-processing': {\n name: 'String Processing',\n tests: {\n 'regex-test': {\n name: 'Regex Test',\n fn: function() {\n const pattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/;\n const emails = [\n 'test@example.com',\n 'invalid-email',\n 'another.test@example.co.uk',\n 'john.doe123@sub.domain.com'\n ];\n return emails.map(email => pattern.test(email));\n }\n }\n }\n },\n \n 'cpu-intensive': {\n name: 'CPU Intensive',\n tests: {\n 'fibonacci-10': {\n name: 'Fibonacci(10)',\n fn: function() {\n const n = 10;\n let a = 0, b = 1;\n for (let i = 2; i <= n; i++) {\n [a, b] = [b, a + b];\n }\n return b;\n }\n },\n \n 'fibonacci-30': {\n name: 'Fibonacci(30)',\n fn: function() {\n const n = 30;\n let a = 0, b = 1;\n for (let i = 2; i <= n; i++) {\n [a, b] = [b, a + b];\n }\n return b;\n }\n },\n \n 'fibonacci-40': {\n name: 'Fibonacci(40)',\n fn: function() {\n const n = 40;\n let a = 0, b = 1;\n for (let i = 2; i <= n; i++) {\n [a, b] = [b, a + b];\n }\n return b;\n }\n },\n \n 'fibonacci-recursive-10': {\n name: 'Fibonacci Recursive(10)',\n fn: function() {\n function fibRecursive(n) {\n if (n <= 1) return n;\n return fibRecursive(n - 1) + fibRecursive(n - 2);\n }\n return fibRecursive(10);\n }\n }\n }\n }\n};\n\nfunction formatNumber(num) {\n return new Intl.NumberFormat().format(Math.round(num));\n}\n\nasync function runBenchNode() {\n console.log('\\n🔍 Running bench-node tests... (detailed output hidden)');\n \n // Save original console.log\n const originalConsoleLog = console.log;\n // Replace with no-op function\n console.log = () => {};\n \n const results = [];\n \n try {\n for (const [suiteKey, suite] of Object.entries(testSuites)) {\n const benchSuite = new Suite({ name: suite.name });\n \n Object.entries(suite.tests).forEach(([testKey, test]) => {\n benchSuite.add(test.name, test.fn);\n });\n \n try {\n const suiteResults = await benchSuite.run();\n \n // Collect results\n suiteResults.forEach(result => {\n // Extract ops/sec from the bench-node result object\n // The opsSec field contains the operations per second value\n let opsPerSec = 0;\n \n if (typeof result.opsSec === 'number') {\n // Direct extraction from the opsSec field\n opsPerSec = result.opsSec;\n } else if (typeof result.hz === 'number') {\n // Fallback to hz if available\n opsPerSec = result.hz;\n } else if (result.stats && typeof result.stats.mean === 'number') {\n // Mean is in nanoseconds, convert to ops/sec\n opsPerSec = 1_000_000_000 / result.stats.mean;\n } else if (typeof result.avg === 'number') {\n // Avg is in seconds, convert to ops/sec\n opsPerSec = 1 / result.avg;\n }\n \n results.push({\n tool: 'bench-node',\n suite: suite.name,\n test: result.name,\n opsPerSec: opsPerSec,\n margin: result.rme || 0\n });\n });\n } catch (error) {\n // Temporarily restore console.log for error reporting\n const tempConsole = console.log;\n console.log = originalConsoleLog;\n console.log(`Error running benchmark suite ${suite.name}: ${error.message}`);\n console.log = tempConsole;\n \n // Add placeholder results for this suite so we don't lose the comparison\n Object.entries(suite.tests).forEach(([testKey, test]) => {\n results.push({\n tool: 'bench-node',\n suite: suite.name,\n test: test.name,\n opsPerSec: 0,\n margin: 0\n });\n });\n }\n }\n } catch (error) {\n // Temporarily restore console.log for error reporting\n const tempConsole = console.log;\n console.log = originalConsoleLog;\n console.log(`Error in bench-node benchmarks: ${error.message}`);\n console.log = tempConsole;\n }\n \n // Restore original console.log\n console.log = originalConsoleLog;\n return results;\n}\n\n\nasync function runBenchmarkJS() {\n console.log('\\n🔍 Running benchmark.js tests... (detailed output hidden)');\n \n // Save original console.log\n const originalConsoleLog = console.log;\n // Replace with no-op function\n console.log = () => {};\n \n const results = [];\n \n try {\n for (const [suiteKey, suite] of Object.entries(testSuites)) {\n await new Promise((resolve) => {\n const benchSuite = new Benchmark.Suite(suite.name);\n \n Object.entries(suite.tests).forEach(([testKey, test]) => {\n benchSuite.add(test.name, test.fn);\n });\n \n benchSuite\n .on('cycle', (event) => {\n // Collect result for each test\n results.push({\n tool: 'benchmark.js',\n suite: suite.name,\n test: event.target.name,\n opsPerSec: event.target.hz,\n margin: event.target.stats.rme\n });\n })\n .on('complete', function() {\n resolve();\n })\n .run();\n });\n }\n } catch (error) {\n // Temporarily restore console.log for error reporting\n const tempConsole = console.log;\n console.log = originalConsoleLog;\n console.log(`Error in benchmark.js benchmarks: ${error.message}`);\n console.log = tempConsole;\n }\n \n // Restore original console.log\n console.log = originalConsoleLog;\n return results;\n}\n\nasync function runMitata() {\n console.log('\\n🔍 Running mitata tests... (detailed output hidden)');\n \n // Save original console.log\n const originalConsoleLog = console.log;\n // Replace with no-op function\n console.log = () => {};\n\n // Create a results collection\n const results = [];\n \n try {\n // Store test to name mappings for result collection\n const testMap = new Map();\n \n for (const [suiteKey, suite] of Object.entries(testSuites)) {\n // Estimate performance based on test function execution time\n Object.entries(suite.tests).forEach(([testKey, test]) => {\n const fullName = `${suite.name}: ${test.name}`;\n bench(fullName, test.fn);\n \n // Create a test mapping\n testMap.set(fullName, { suite: suite.name, test: test.name });\n \n // Do a simple performance estimate (not as accurate as real benchmark)\n // This is a fallback since we can't easily extract mitata results\n const start = process.hrtime.bigint();\n const iterations = 1000;\n for (let i = 0; i < iterations; i++) {\n test.fn();\n }\n const end = process.hrtime.bigint();\n const avgNs = Number(end - start) / iterations;\n const estOpsPerSec = 1_000_000_000 / avgNs;\n \n // Add estimated result\n results.push({\n tool: 'mitata',\n suite: suite.name,\n test: test.name,\n opsPerSec: estOpsPerSec,\n margin: 5 // Rough estimate of margin\n });\n });\n }\n \n // Run mitata benchmarks silently\n await mitataRun();\n } catch (error) {\n // Temporarily restore console.log for error reporting\n const tempConsole = console.log;\n console.log = originalConsoleLog;\n console.log(`Error in mitata benchmarks: ${error.message}`);\n console.log = tempConsole;\n }\n \n // Restore original console.log\n console.log = originalConsoleLog;\n return results;\n}\n\n\nasync function runTinyBench() {\n console.log('\\n🔍 Running tinybench tests... (detailed output hidden)');\n \n // Save original console.log\n const originalConsoleLog = console.log;\n // Replace with no-op function\n console.log = () => {};\n \n const allResults = [];\n \n try {\n // Create benchmarks for each suite\n for (const [suiteKey, suite] of Object.entries(testSuites)) {\n const benchmark = new Bench();\n \n // Add tests to suite\n Object.entries(suite.tests).forEach(([testKey, test]) => {\n benchmark.add(test.name, test.fn);\n });\n \n // Run benchmarks\n await benchmark.run();\n \n // Format and collect results\n const suiteResults = benchmark.tasks.map(({ name, result }) => ({\n name,\n ops: result?.hz || 0,\n margin: result?.rme ? `±${result?.rme.toFixed(2)}%` : 'N/A'\n }));\n suiteResults.forEach(result => {\n // Extract numeric margin value from the margin string (e.g., '±1.20%' -> 1.20)\n let marginValue = 0;\n if (result.margin && result.margin !== 'N/A') {\n const match = result.margin.match(/[0-9.]+/);\n if (match) {\n marginValue = parseFloat(match[0]);\n }\n }\n \n allResults.push({\n tool: 'tinybench',\n suite: suite.name,\n test: result.name,\n opsPerSec: result.ops,\n margin: marginValue\n });\n });\n }\n } catch (error) {\n // Temporarily restore console.log for error reporting\n const tempConsole = console.log;\n console.log = originalConsoleLog;\n console.log(`Error in tinybench benchmarks: ${error.message}`);\n console.log = tempConsole;\n }\n \n // Restore original console.log\n console.log = originalConsoleLog;\n return allResults;\n}\n\n\nfunction compareResults(results) {\n console.log('\\n📈 BENCHMARK COMPARISON SUMMARY');\n console.log('============================');\n \n // Group results by suite and test\n const resultsBySuiteAndTest = {};\n \n results.forEach(result => {\n // Ensure we have valid ops/sec values for comparison\n if (isNaN(result.opsPerSec) || result.opsPerSec === undefined || result.opsPerSec === null) {\n result.opsPerSec = 0;\n }\n \n const key = `${result.suite} - ${result.test}`;\n if (!resultsBySuiteAndTest[key]) {\n resultsBySuiteAndTest[key] = [];\n }\n resultsBySuiteAndTest[key].push(result);\n });\n \n // For each test case, compare across tools\n Object.entries(resultsBySuiteAndTest).forEach(([testCase, testResults]) => {\n console.log(`\\n📏 Test Case: ${testCase}`);\n \n const comparisonTable = testResults.map(result => ({\n 'Tool': result.tool,\n 'ops/sec': formatNumber(result.opsPerSec || 0),\n 'margin': result.margin ? `±${result.margin.toFixed(2)}%` : 'N/A',\n 'relative': '1x'\n }));\n \n // Find the fastest tool for this test (with valid non-zero result)\n const validResults = testResults.filter(r => r.opsPerSec > 0);\n const fastest = validResults.length > 0 ?\n validResults.reduce((max, result) => result.opsPerSec > max.opsPerSec ? result : max, validResults[0]) :\n { opsPerSec: 1 };\n \n // Calculate relative performance\n comparisonTable.forEach(row => {\n const result = testResults.find(r => r.tool === row['Tool']);\n if (result && result.opsPerSec > 0 && fastest.opsPerSec > 0) {\n const relative = result.opsPerSec / fastest.opsPerSec;\n row['relative'] = `${relative.toFixed(2)}x`;\n } else {\n row['relative'] = 'N/A';\n }\n });\n \n // Sort by performance (descending)\n comparisonTable.sort((a, b) => {\n const aResult = testResults.find(r => r.tool === a['Tool']);\n const bResult = testResults.find(r => r.tool === b['Tool']);\n const aSpeed = aResult && aResult.opsPerSec > 0 ? aResult.opsPerSec : 0;\n const bSpeed = bResult && bResult.opsPerSec > 0 ? bResult.opsPerSec : 0;\n return bSpeed - aSpeed;\n });\n \n console.table(comparisonTable);\n });\n}\n\nasync function main() {\n console.log('🚀 BENCHMARK COMPARISON');\n console.log('======================');\n console.log('Comparing: bench-node, benchmark.js, mitata, tinybench\\n');\n\n try {\n const results = [];\n \n // Run all benchmarks and collect results\n const benchNodeResults = await runBenchNode();\n const benchmarkJsResults = await runBenchmarkJS();\n const mitataResults = await runMitata();\n const tinyBenchResults = await runTinyBench();\n \n // Combine all results\n results.push(...benchNodeResults);\n results.push(...benchmarkJsResults);\n results.push(...mitataResults);\n results.push(...tinyBenchResults);\n \n // Compare results across all tools\n compareResults(results);\n \n console.log('\\n✅ All benchmarks completed successfully!');\n } catch (error) {\n console.error('❌ Error running benchmarks:', error);\n }\n}\n\nmain();\n"
},
{
"path": "examples/chart-report/node.js",
"content": "const { Suite, chartReport } = require('../../lib');\nconst assert = require('node:assert');\n\nasync function runSuiteOne() {\n const suite = new Suite({\n reporter: chartReport,\n });\n\n await suite\n .add('test 1', function () {\n const pattern = /[123]/g\n })\n .add('test 2', function () {\n const subject = '123123123123123123123123123123123123123123123123'\n const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')\n })\n .run();\n}\n\nasync function runSuiteTwo() {\n const suite = new Suite({\n reporter: chartReport,\n reporterOptions: {\n printHeader: false\n }\n });\n\n await suite\n .add('test 3', function () {\n const pattern = /[123]/g\n })\n .add('test 4', function () {\n const subject = '123123123123123123123123123123123123123123123123'\n const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')\n assert.ok(r)\n })\n .run();\n}\n\nasync function main() {\n await runSuiteOne()\n process.stdout.write('\\n\\n')\n await runSuiteTwo()\n}\n\nmain()\n"
},
{
"path": "examples/create-uint32array/node.js",
"content": "const { Suite } = require('../../lib');\n\nconst suite = new Suite();\n\nsuite\n .add(`new Uint32Array(1024)`, { baseline: true }, function () {\n return new Uint32Array(1024);\n })\n .add(`new Uint32Array(1024) with 10 repetitions`, {repeatSuite: 10}, function () {\n return new Uint32Array(1024);\n })\n .add(`new Uint32Array(1024) with min samples of 50`, {minSamples: 50}, function() {\n return new Uint32Array(1024);\n })\n .add(`[Managed] new Uint32Array(1024)`, function (timer) {\n const assert = require('node:assert');\n\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = new Uint32Array(1024);\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .run();\n"
},
{
"path": "examples/create-uint32array/node.js.log",
"content": "new Uint32Array(1024) x 2,930,763 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(332.08ns ... 355.52ns) p75=344.36ns p99=355.52ns\n[Managed] new Uint32Array(1024) x 2,934,651 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(335.94ns ... 357.76ns) p75=340.16ns p99=357.76ns\n----------------------------------------------------------------------------\nnew Uint32Array(1024) x 2,967,727 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(330.75ns ... 337.55ns) p75=334.98ns p99=337.55ns\n[Managed] new Uint32Array(1024) x 3,029,150 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(326.51ns ... 341.28ns) p75=331.01ns p99=341.28ns\n----------------------------------------------------------------------------\nnew Uint32Array(1024) x 2,920,851 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(332.88ns ... 363.08ns) p75=348.19ns p99=363.08ns\n[Managed] new Uint32Array(1024) x 3,032,256 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(327.13ns ... 343.75ns) p75=329.19ns p99=343.75ns\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/crypto-verify/node.js",
"content": "const crypto = require('node:crypto');\nconst { readFileSync } = require('fs');\nconst { Suite } = require('../../lib');\n\nconst rsaPrivateKey = readFileSync(`${__dirname}/private-key.pem`, 'utf-8');\nconst rsaPublicKey = readFileSync(`${__dirname}/public-key.pem`, 'utf-8');\n\nconst thing = 'hello world';\nconst algorithm = 'RSA-SHA256';\nconst signature = crypto.createSign(algorithm).update(thing).sign(rsaPrivateKey, 'base64');\n\nconst suite = new Suite();\n\nsuite\n .add(`crypto.createVerify('${algorithm}')`, function () {\n var verifier = crypto.createVerify(algorithm);\n verifier.update(thing);\n verifier.verify(rsaPublicKey, signature, 'base64');\n })\n .add(`crypto.verify('${algorithm}')`, function () {\n crypto.verify(algorithm, thing, rsaPublicKey, Buffer.from(signature, 'base64'));\n })\n .add(`[Managed] crypto.createVerify('RSA-SHA256')`, function (timer) {\n const crypto = require('node:crypto');\n const { readFileSync } =require('node:fs');\n const assert = require('node:assert');\n\n const rsaPrivateKey = readFileSync(`${__dirname}/private-key.pem`, 'utf-8');\n const rsaPublicKey = readFileSync(`${__dirname}/public-key.pem`, 'utf-8');\n\n const thing = 'hello world'\n const signature = crypto.createSign('RSA-SHA256').update(thing).sign(rsaPrivateKey, 'base64')\n\n let verifier;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n verifier = crypto.createVerify('RSA-SHA256')\n verifier.update(thing)\n verifier.verify(rsaPublicKey, signature, 'base64')\n }\n timer.end(timer.count);\n\n assert.ok(verifier);\n })\n .add(`[Managed] crypto.verify('RSA-SHA256')`, function (timer) {\n const crypto = require('node:crypto');\n const { readFileSync } = require('node:fs');\n const assert = require('node:assert');\n\n const rsaPrivateKey = readFileSync(`${__dirname}/private-key.pem`, 'utf-8');\n const rsaPublicKey = readFileSync(`${__dirname}/public-key.pem`, 'utf-8');\n\n const thing = 'hello world'\n const signature = crypto.createSign('RSA-SHA256').update(thing).sign(rsaPrivateKey, 'base64')\n\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = crypto.verify('RSA-SHA256', thing, rsaPublicKey, Buffer.from(signature, 'base64'));\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .run();\n"
},
{
"path": "examples/crypto-verify/node.js.log",
"content": "crypto.createVerify('RSA-SHA256') x 10,925 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(88.50us ... 93.51us) p75=91.54us p99=93.51us\ncrypto.verify('RSA-SHA256') x 10,988 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(90.93us ... 91.84us) p75=91.58us p99=91.84us\n[Managed] crypto.createVerify('RSA-SHA256') x 10,520 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(88.44us ... 92.23us) p75=91.47us p99=92.23us\n[Managed] crypto.verify('RSA-SHA256') x 10,948 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(89.98us ... 92.36us) p75=91.49us p99=92.36us\n----------------------------------------------------------------------------\ncrypto.createVerify('RSA-SHA256') x 10,807 ops/sec (8 runs sampled) v8-never-optimize=true min..max=(91.66us ... 92.58us) p75=92.23us p99=92.58us\ncrypto.verify('RSA-SHA256') x 10,964 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(88.95us ... 92.46us) p75=91.83us p99=92.46us\n[Managed] crypto.createVerify('RSA-SHA256') x 10,954 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(90.08us ... 92.88us) p75=91.72us p99=92.88us\n[Managed] crypto.verify('RSA-SHA256') x 10,990 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(90.31us ... 92.43us) p75=91.43us p99=92.43us\n----------------------------------------------------------------------------\ncrypto.createVerify('RSA-SHA256') x 10,890 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(87.88us ... 94.08us) p75=92.96us p99=94.08us\ncrypto.verify('RSA-SHA256') x 10,906 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(91.03us ... 92.45us) p75=91.66us p99=92.45us\n[Managed] crypto.createVerify('RSA-SHA256') x 11,050 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(87.94us ... 92.09us) p75=91.88us p99=92.09us\n[Managed] crypto.verify('RSA-SHA256') x 10,990 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(90.29us ... 92.13us) p75=91.92us p99=92.13us\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/crypto-verify/private-key.pem",
"content": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEAz7QweYwr7puNtc8/6jf4pADXfY2/HVq7LgI7JXkAwW5HTEjU\nRvu02SYC7n/ylr86Da4hcAEAFBC2baVh7J0EnLo6D4FA3yV4s5zj7tqL+p2CdniY\nMDEny+uxS/9eRuLf1RIYHjSVB6wOoU4lg9FtDOQA8W09ZDLvc3/4ZSwEf9O2J5Vm\nqcSGaPt35eIEBS0iIMiOUCGqbUcVMZkp4JO7I65HOK/g0Scvb1LLY6f4qDsThqyi\nID/NXM5LtjnztRP+9dCLT9DdwC+LeU2te6vcEwC2bPYs3nUwkZL4qqIWO6GHaavn\ngFKSmbmc9muVAPmYW/ffMtznKZaWCp9Li0JGuQIDAQABAoIBAQC7OI7hYSpQgEKy\neUgBlcY3/tI/SD/W8+v5QuWRl4rI0ODPsG44NbcEbbECzq4al/B6WFWnoh8x9waZ\nuxOTts1rgKnJRBb3jc1JCcijirfWhZgNthJojkZzF9bOzDds6iAc7Zxzza3wJnVh\njRFfyqzji7oV5QQLh6YzlEyQ1aaQmOKTkCDV1UDetI8iItUvq3i8EwsFmtfvXjTl\naymL/xSd3R6w3WDEd8PS5ZPDoFmkt2h/4IhOo6bVXLwWBWqcopRAvzGQrc806c2l\njjePwk9fddIG+vIHc8DHqaC/WzMR6iBt3K7Q9Eyu4k97qeOxB5TIEVlhxg2DJON9\nDlGtInXpAoGBAPje3L0xL441i7kh7GqiWtXiDgxVwdPmN5p7n755MddSxvu8894h\nT9/LxwAVcpolXANgyRtrl5bu/gXgznKefmVr976BzG2DY33PESf5FnHZAmixWSfz\nVOdfVlz+Bk/BI+nVwmeT0+8NSHJ6TJ/9NOSzI9ctUceszIHG5/Gfc2wHAoGBANWn\nbHNT7aphFqyUMfWyc6+h8Radq/RVMrOGeD2wRRqUTeb2Ydbx2OwB+gcwnlbsQjfS\nBYAa3kn1z5K5kOigB9qu6x7zuM9SMReKIlMg3NpYVyKKj+JaNF3YArFa5TWy0B26\nwNJ0FiiZyPq4eP5hPwM+Bed4ytIRWa54P5GeRYc/AoGAWT8ijb4rvaW6G4Ps0jiy\ntmzAeO/v+FtgqUeX+6helUccEH6sPYZYrHrZPFB0ro6jNprow6qLzBacheMeZcAs\nt5ZGW80UUFmDvkQZdOpAgEdAM+cVf9wlIGvx/psiDEvI4zxC4P4ETH/I8TSmceFN\nrI4JVkrsPtza4ddAqkdyDtUCgYAaoMs7dHJikccpqy6u2JbihORvVSdhRF0VUuUZ\niyaRsXokFwEKsQnAIF7xFnYljzyRiHN3C+I4hZJhTw9obsmLz9EuAmI+NJg5vtWY\nVrgv3mK9w1c7dtKf/5QWVqXKk4asreHqWN2KIeCSnvs1eRlJZimGN9/PXqo2vHXv\nyDISMQKBgE22EhVB99rEsLXDCXOUHIFGpW46ZavQc4DLXg+uIQm3y0WWyc0oyNF8\n9kr1luu5QI5PV9mWpSKa3SKmc74biyxhlUp/DYuMyuSXpdDegMAKheAHVXP9ToU/\n5qhq4HBcISN3CwSAYcFcbqC3cB07T+IwX6NTEz4zel4gty8t/tsM\n-----END RSA PRIVATE KEY-----"
},
{
"path": "examples/crypto-verify/public-key.pem",
"content": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz7QweYwr7puNtc8/6jf4\npADXfY2/HVq7LgI7JXkAwW5HTEjURvu02SYC7n/ylr86Da4hcAEAFBC2baVh7J0E\nnLo6D4FA3yV4s5zj7tqL+p2CdniYMDEny+uxS/9eRuLf1RIYHjSVB6wOoU4lg9Ft\nDOQA8W09ZDLvc3/4ZSwEf9O2J5VmqcSGaPt35eIEBS0iIMiOUCGqbUcVMZkp4JO7\nI65HOK/g0Scvb1LLY6f4qDsThqyiID/NXM5LtjnztRP+9dCLT9DdwC+LeU2te6vc\nEwC2bPYs3nUwkZL4qqIWO6GHaavngFKSmbmc9muVAPmYW/ffMtznKZaWCp9Li0JG\nuQIDAQAB\n-----END PUBLIC KEY-----"
},
{
"path": "examples/csv-report/node.js",
"content": "const { Suite } = require('../../lib');\nconst assert = require('node:assert');\n\nconst suite = new Suite();\n\nsuite\n .add('single with matcher', function () {\n const pattern = /[123]/g\n const replacements = { 1: 'a', 2: 'b', 3: 'c' }\n const subject = '123123123123123123123123123123123123123123123123'\n const r = subject.replace(pattern, m => replacements[m])\n assert.ok(r);\n })\n .add('multiple replaces', function () {\n const subject = '123123123123123123123123123123123123123123123123'\n const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')\n assert.ok(r);\n })\n .run();\n"
},
{
"path": "examples/dce-detection/example.js",
"content": "const { Suite } = require(\"../../lib/index\");\n\n// Enable DCE detection to catch benchmarks that may be optimized away\nconst suite = new Suite({\n\tdetectDeadCodeElimination: true,\n});\n\n// Example 1: Likely to trigger DCE warning - result not used\nsuite.add(\"simple addition (likely DCE)\", () => {\n\tconst result = 1 + 1;\n\t// result is never used - JIT might optimize this away\n});\n\n// Example 2: Result is used - should not trigger warning\nsuite.add(\"simple addition (used)\", () => {\n\tconst result = 1 + 1;\n\tif (result !== 2) throw new Error(\"Unexpected result\");\n});\n\n// Example 3: Array creation without use - likely DCE\nsuite.add(\"array creation (likely DCE)\", () => {\n\tconst arr = new Array(100);\n\t// arr is never accessed - might be optimized away\n});\n\n// Example 4: Array creation with access - should not trigger warning\nsuite.add(\"array creation (accessed)\", () => {\n\tconst arr = new Array(100);\n\tarr[0] = 1; // Using the array\n});\n\n// Example 5: Object creation without use - likely DCE\nsuite.add(\"object creation (likely DCE)\", () => {\n\tconst obj = { x: 1, y: 2, z: 3 };\n\t// obj is never accessed\n});\n\n// Example 6: More realistic computation\nsuite.add(\"string operations\", () => {\n\tconst str1 = \"hello\";\n\tconst str2 = \"world\";\n\tconst result = str1 + \" \" + str2;\n\tif (!result.includes(\"hello\")) throw new Error(\"Missing hello\");\n});\n\nsuite.run();\n"
},
{
"path": "examples/dce-detection/with-dce-disabled.js",
"content": "const { Suite } = require(\"../../lib/index\");\n\n// Default behavior - DCE detection is disabled, V8NeverOptimizePlugin is used\n// You don't need to set detectDeadCodeElimination: false explicitly\nconst suite = new Suite();\n\n// These benchmarks will run with V8NeverOptimizePlugin, so they'll be slower\n// but more deterministic and won't be optimized away\nsuite.add(\"simple addition\", () => {\n\tconst result = 1 + 1;\n});\n\nsuite.add(\"array creation\", () => {\n\tconst arr = new Array(100);\n});\n\nsuite.run();\n"
},
{
"path": "examples/dce-detection/without-never-optimize.js",
"content": "const { Suite } = require(\"../../lib/index\");\n\n// Enable DCE detection - this automatically disables V8NeverOptimizePlugin\n// In this mode, V8 optimizations occur naturally and DCE warnings help identify issues\nconst suite = new Suite({\n\tdetectDeadCodeElimination: true,\n});\n\n// Example 1: Likely to trigger DCE warning - result not used\nsuite.add(\"simple addition (likely DCE)\", () => {\n\tconst result = 1 + 1;\n\t// result is never used - JIT will optimize this away\n});\n\n// Example 2: Result is used - should not trigger warning\nsuite.add(\"simple addition (used)\", () => {\n\tconst result = 1 + 1;\n\tif (result !== 2) throw new Error(\"Unexpected result\");\n});\n\n// Example 3: Array creation without use - likely DCE\nsuite.add(\"array creation (likely DCE)\", () => {\n\tconst arr = new Array(100);\n\t// arr is never accessed - will be optimized away\n});\n\n// Example 4: Array creation with access - should not trigger warning\nsuite.add(\"array creation (accessed)\", () => {\n\tconst arr = new Array(100);\n\tarr[0] = 1; // Using the array\n});\n\n// Example 5: More realistic computation that takes time\nsuite.add(\"actual work\", () => {\n\tlet sum = 0;\n\tfor (let i = 0; i < 100; i++) {\n\t\tsum += Math.sqrt(i);\n\t}\n\tif (sum < 0) throw new Error(\"Impossible\");\n});\n\nsuite.run();\n"
},
{
"path": "examples/deleting-properties/node.js",
"content": "const { Suite } = require('../../lib');\n\nconst suite = new Suite();\n\nconst NullObject = function NullObject() { }\nNullObject.prototype = Object.create(null);\n%NeverOptimizeFunction(NullObject);\n\nsuite\n .add('Using delete property', function () {\n const data = { x: 1, y: 2, z: 3 }\n delete data.y\n\n data.x\n data.y\n data.z\n })\n .add('Using delete property (proto: null)', function () {\n const data = { __proto__: null, x: 1, y: 2, z: 3 }\n delete data.y\n\n data.x\n data.y\n data.z\n })\n .add('Using delete property (cached proto: null)', function () {\n const data = new NullObject()\n\n data.x = 1\n data.y = 2\n data.z = 3\n\n delete data.y\n\n data.x\n data.y\n data.z\n })\n .add('Using undefined assignment', function () {\n const data = { x: 1, y: 2, z: 3 }\n data.y = undefined\n\n data.x\n data.y\n data.z\n })\n .add('Using undefined assignment (proto: null)', function () {\n const data = { __proto__: null, x: 1, y: 2, z: 3 }\n data.y = undefined\n\n data.x\n data.y\n data.z\n })\n .add('Using undefined property (cached proto: null)', function () {\n const data = new NullObject()\n\n data.x = 1\n data.y = 2\n data.z = 3\n\n data.y = undefined\n\n data.x\n data.y\n data.z\n })\n .add('[Managed] Using undefined property (cached proto: null)', function (t) {\n const NullObject = function () { }\n NullObject.prototype = Object.create(null)\n\n t.start();\n for (let i = 0; i < t.count; i++) {\n const data = new NullObject()\n\n data.x = 1\n data.y = 2\n data.z = 3\n\n data.y = undefined\n\n data.x\n data.y\n data.z\n }\n t.end(t.count);\n })\n .run();\n"
},
{
"path": "examples/deleting-properties/node.js.log",
"content": "Using delete property x 7,763,866 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(128.11ns ... 129.99ns) p75=129.03ns p99=129.99ns\nUsing delete property (proto: null) x 22,946,068 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(43.13ns ... 44.11ns) p75=43.74ns p99=44.11ns\nUsing delete property (cached proto: null) x 7,331,951 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(135.64ns ... 137.39ns) p75=136.52ns p99=137.39ns\nUsing undefined assignment x 133,449,849 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(7.45ns ... 7.56ns) p75=7.53ns p99=7.56ns\nUsing undefined assignment (proto: null) x 25,432,632 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(38.72ns ... 40.06ns) p75=39.60ns p99=40.06ns\nUsing undefined property (cached proto: null) x 58,871,059 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(16.92ns ... 17.12ns) p75=17.01ns p99=17.12ns\n[Managed] Using undefined property (cached proto: null) x 35,463,712 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(28.05ns ... 28.43ns) p75=28.25ns p99=28.43ns\n----------------------------------------------------------------------------\nUsing delete property x 6,669,856 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(149.14ns ... 151.02ns) p75=150.12ns p99=151.02ns\nUsing delete property (proto: null) x 15,242,131 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(64.77ns ... 66.38ns) p75=66.25ns p99=66.38ns\nUsing delete property (cached proto: null) x 5,920,843 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(167.87ns ... 170.33ns) p75=169.07ns p99=170.33ns\nUsing undefined assignment x 78,647,245 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(12.62ns ... 12.83ns) p75=12.70ns p99=12.83ns\nUsing undefined assignment (proto: null) x 16,278,910 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(60.79ns ... 62.25ns) p75=61.57ns p99=62.25ns\nUsing undefined property (cached proto: null) x 27,262,884 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(36.54ns ... 36.65ns) p75=36.62ns p99=36.65ns\n[Managed] Using undefined property (cached proto: null) x 28,068,785 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(35.07ns ... 35.79ns) p75=35.67ns p99=35.79ns\n----------------------------------------------------------------------------\nUsing delete property x 7,632,095 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(129.63ns ... 132.85ns) p75=131.19ns p99=132.85ns\nUsing delete property (proto: null) x 23,040,357 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(43.06ns ... 44.20ns) p75=43.56ns p99=44.20ns\nUsing delete property (cached proto: null) x 7,222,103 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(137.05ns ... 139.88ns) p75=139.18ns p99=139.88ns\nUsing undefined assignment x 133,133,677 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(7.49ns ... 7.53ns) p75=7.52ns p99=7.53ns\nUsing undefined assignment (proto: null) x 25,217,884 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(39.24ns ... 40.48ns) p75=39.89ns p99=40.48ns\nUsing undefined property (cached proto: null) x 58,899,972 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(16.94ns ... 17.03ns) p75=16.99ns p99=17.03ns\n[Managed] Using undefined property (cached proto: null) x 34,904,120 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(28.34ns ... 29.89ns) p75=28.84ns p99=29.89ns\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/empty/node.js",
"content": "const { Suite } = require('../../lib');\n\nconst suite = new Suite();\n\nsuite\n .add(`empty`, function () {})\n .add(`empty async`, async function () {})\n .run();\n"
},
{
"path": "examples/empty/node.js.log",
"content": "empty x 218,984,985 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(4.53ns ... 4.66ns) p75=4.58ns p99=4.66ns\nempty async x 20,898,403 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(47.46ns ... 48.57ns) p75=48.04ns p99=48.57ns\n----------------------------------------------------------------------------\nempty x 220,571,877 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(4.49ns ... 4.61ns) p75=4.58ns p99=4.61ns\nempty async x 20,925,022 ops/sec (14 runs sampled) v8-never-optimize=true min..max=(37.43ns ... 48.60ns) p75=48.03ns p99=48.60ns\n----------------------------------------------------------------------------\nempty x 218,923,690 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(4.52ns ... 4.64ns) p75=4.59ns p99=4.64ns\nempty async x 20,792,931 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(42.94ns ... 49.45ns) p75=48.54ns p99=49.45ns\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/fs-read-async/node.js",
"content": "const { Suite } = require('../../lib');\nconst { readFile } = require('node:fs/promises');\nconst { resolve } = require('node:path');\n\nconst suite = new Suite();\n\nconst sampleFile = resolve(__dirname, 'sample-file.txt');\n\nsuite\n .add('readFile', async function () {\n const r = await readFile(sampleFile);\n })\n .add('readFile utf-8', async function () {\n const r = await readFile(sampleFile, 'utf-8');\n })\n .add('[managed] readFile', async function (timer) {\n const { readFile } = require('node:fs/promises');\n const { resolve } = require('node:path');\n const assert = require('node:assert');\n\n const sampleFile = resolve(__dirname, 'sample-file.txt');\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = await readFile(sampleFile);\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .add('[managed] readFile utf-8', async function (timer) {\n const { readFile } = require('node:fs/promises');\n const { resolve } = require('node:path');\n const assert = require('node:assert');\n\n const sampleFile = resolve(__dirname, 'sample-file.txt');\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = await readFile(sampleFile, 'utf-8');\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .run();\n"
},
{
"path": "examples/fs-read-async/node.js.log",
"content": "readFile x 23,167 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.59us ... 43.59us) p75=43.42us p99=43.59us\nreadFile utf-8 x 23,021 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(43.14us ... 43.92us) p75=43.64us p99=43.92us\n[managed] readFile x 23,386 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.63us ... 43.04us) p75=42.89us p99=43.04us\n[managed] readFile utf-8 x 23,302 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.76us ... 43.30us) p75=43.01us p99=43.30us\n----------------------------------------------------------------------------\nreadFile x 23,177 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.70us ... 43.54us) p75=43.31us p99=43.54us\nreadFile utf-8 x 23,155 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.34us ... 43.53us) p75=43.15us p99=43.53us\n[managed] readFile x 23,538 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.22us ... 42.82us) p75=42.59us p99=42.82us\n[managed] readFile utf-8 x 23,458 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.11us ... 43.20us) p75=42.86us p99=43.20us\n----------------------------------------------------------------------------\nreadFile x 23,235 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.73us ... 43.41us) p75=43.17us p99=43.41us\nreadFile utf-8 x 23,130 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.90us ... 44.40us) p75=43.62us p99=44.40us\n[managed] readFile x 23,490 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.40us ... 42.89us) p75=42.66us p99=42.89us\n[managed] readFile utf-8 x 23,553 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(41.99us ... 42.81us) p75=42.58us p99=42.81us\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/fs-read-async/node.managed.js",
"content": "const { Suite } = require('../../lib');\n\nconst suite = new Suite();\n\nsuite\n .add('readFile', async function (timer) {\n const { readFile } = require('node:fs/promises');\n const { resolve } = require('node:path');\n const assert = require('node:assert');\n\n const sampleFile = resolve(__dirname, 'sample-file.txt');\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = await readFile(sampleFile);\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .add('readFile utf-8', async function (timer) {\n const { readFile } = require('node:fs/promises');\n const { resolve } = require('node:path');\n const assert = require('node:assert');\n\n const sampleFile = resolve(__dirname, 'sample-file.txt');\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = await readFile(sampleFile, 'utf-8');\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .run();\n"
},
{
"path": "examples/fs-read-async/node.managed.js.log",
"content": "readFile x 23,066 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.59us ... 43.63us) p75=43.20us p99=43.63us\nreadFile utf-8 x 23,334 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(42.21us ... 43.70us) p75=42.96us p99=43.70us\n----------------------------------------------------------------------------\nreadFile x 23,145 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.64us ... 43.18us) p75=43.04us p99=43.18us\nreadFile utf-8 x 23,324 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.54us ... 43.80us) p75=42.93us p99=43.80us\n----------------------------------------------------------------------------\nreadFile x 23,124 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(42.36us ... 43.30us) p75=42.99us p99=43.30us\nreadFile utf-8 x 23,277 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(41.50us ... 43.88us) p75=42.98us p99=43.88us\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/fs-read-async/sample-file.txt",
"content": "hello"
},
{
"path": "examples/fs-read-sync/node.js",
"content": "const { Suite } = require('../../lib');\nconst { readFileSync } = require('node:fs');\nconst { resolve } = require('node:path');\n\nconst suite = new Suite();\n\nconst sampleFile = resolve(__dirname, 'sample-file.txt');\n\nsuite\n .add('readFileSync', function () {\n const r = readFileSync(sampleFile);\n })\n .add('readFileSync utf-8', function () {\n const r = readFileSync(sampleFile, 'utf-8');\n })\n .add('[Managed] readFileSync', function (timer) {\n const { readFileSync } = require('node:fs');\n const { resolve } = require('node:path');\n const assert = require('node:assert');\n\n const sampleFile = resolve(__dirname, 'sample-file.txt');\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = readFileSync(sampleFile);\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n .add('[Managed] readFileSync utf-8', function (timer) {\n const { readFileSync } = require('node:fs');\n const { resolve } = require('node:path');\n const assert = require('node:assert');\n\n const sampleFile = resolve(__dirname, 'sample-file.txt');\n let r;\n\n timer.start();\n for (let i = 0; i < timer.count; i++) {\n r = readFileSync(sampleFile, 'utf-8');\n }\n timer.end(timer.count);\n\n assert.ok(r);\n })\n\n .run();\n"
},
{
"path": "examples/fs-read-sync/node.js.log",
"content": "readFileSync x 198,828 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(5.01us ... 5.06us) p75=5.04us p99=5.06us\nreadFileSync utf-8 x 203,828 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(4.88us ... 4.94us) p75=4.92us p99=4.94us\n[Managed] readFileSync x 196,632 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(5.05us ... 5.08us) p75=5.07us p99=5.08us\n[Managed] readFileSync utf-8 x 203,265 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(4.89us ... 4.92us) p75=4.91us p99=4.92us\n----------------------------------------------------------------------------\nreadFileSync x 198,461 ops/sec (9 runs sampled) v8-never-optimize=true min..max=(5.00us ... 5.05us) p75=5.02us p99=5.05us\nreadFileSync utf-8 x 205,171 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(4.82us ... 4.86us) p75=4.86us p99=4.86us\n[Managed] readFileSync x 193,061 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(5.05us ... 5.48us) p75=5.30us p99=5.48us\n[Managed] readFileSync utf-8 x 204,046 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(4.86us ... 4.92us) p75=4.91us p99=4.92us\n----------------------------------------------------------------------------\nreadFileSync x 196,533 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(5.02us ... 5.20us) p75=5.10us p99=5.20us\nreadFileSync utf-8 x 205,213 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(4.83us ... 4.89us) p75=4.86us p99=4.89us\n[Managed] readFileSync x 183,333 ops/sec (12 runs sampled) v8-never-optimize=true min..max=(5.06us ... 6.46us) p75=5.28us p99=6.46us\n[Managed] readFileSync utf-8 x 201,593 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(4.90us ... 5.07us) p75=5.06us p99=5.07us\n----------------------------------------------------------------------------\n"
},
{
"path": "examples/fs-read-sync/sample-file.txt",
"content": "hello"
},
{
"path": "examples/html-report/node.js",
"content": "const { Suite, htmlReport } = require('../../lib');\nconst assert = require('node:assert');\n\nconst suite = new Suite({\n reporter: htmlReport,\n});\n\nsuite\n .add('single with matcher', function () {\n const pattern = /[123]/g\n const replacements = { 1: 'a', 2: 'b', 3: 'c' }\n const subject = '123123123123123123123123123123123123123123123123'\n const r = subject.replace(pattern, m => replacements[m])\n assert.ok(r);\n })\n .add('Multiple replaces', function () {\n const subject = '123123123123123123123123123123123123123123123123'\n const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')\n assert.ok(r);\n })\n .run();\n"
},
{
"path": "examples/html-report/result.html",
"content": "\n\n\n \n \n Benchmark Visualizer\n \n\n\n