deno.land / std@0.157.0 / testing / bench.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
/** * **Deprecated**. Use `Deno.bench()` instead. * * See: https://doc.deno.land/deno/unstable/~/Deno.bench for details. * * @deprecated (will be removed after 0.157.0) Use `Deno.bench()` instead. * @module */
import { assert } from "../_util/assert.ts";import { deepAssign } from "../_util/deep_assign.ts";
interface BenchmarkClock { start: number; stop: number; for?: string;}
/** Provides methods for starting and stopping a benchmark clock. */export interface BenchmarkTimer { start: () => void; stop: () => void;}
/** Defines a benchmark through a named function. */export interface BenchmarkFunction { (b: BenchmarkTimer): void | Promise<void>; name: string;}
/** Defines a benchmark definition with configurable runs. */export interface BenchmarkDefinition { func: BenchmarkFunction; name: string; /** Defines how many times the provided `func` should be benchmarked in succession */ runs?: number;}
/** Defines runBenchmark's run constraints by matching benchmark names. */export interface BenchmarkRunOptions { /** Only benchmarks which name match this regexp will be run*/ only?: RegExp; /** Benchmarks which name match this regexp will be skipped */ skip?: RegExp; /** Setting it to true prevents default benchmarking progress logs to the commandline*/ silent?: boolean;}
/** Defines clearBenchmark's constraints by matching benchmark names. */export interface BenchmarkClearOptions { /** Only benchmarks which name match this regexp will be removed */ only?: RegExp; /** Benchmarks which name match this regexp will be kept */ skip?: RegExp;}
/** Defines the result of a single benchmark */export interface BenchmarkResult { /** The name of the benchmark */ name: string; /** The total time it took to run a given benchmark */ totalMs: number; /** Times the benchmark was run in succession. */ runsCount: number; /** The average time of running the benchmark in milliseconds. */ measuredRunsAvgMs: number; /** The individual measurements in milliseconds it took to run the benchmark.*/ measuredRunsMs: number[];}
/** Defines the result of a `runBenchmarks` call */export interface BenchmarkRunResult { /** How many benchmark were ignored by the provided `only` and `skip` */ filtered: number; /** The individual results for each benchmark that was run */ results: BenchmarkResult[];}
/** Defines the current progress during the run of `runBenchmarks` */export interface BenchmarkRunProgress extends BenchmarkRunResult { /** List of the queued benchmarks to run with their name and their run count */ queued?: Array<{ name: string; runsCount: number }>; /** The currently running benchmark with its name, run count and the already finished measurements in milliseconds */ running?: { name: string; runsCount: number; measuredRunsMs: number[] }; /** Indicates in which state benchmarking currently is */ state?: ProgressState;}
/** Defines the states `BenchmarkRunProgress` can be in */export enum ProgressState { BenchmarkingStart = "benchmarking_start", BenchStart = "bench_start", BenchPartialResult = "bench_partial_result", BenchResult = "bench_result", BenchmarkingEnd = "benchmarking_end",}
export class BenchmarkRunError extends Error { benchmarkName?: string; constructor(msg: string, benchmarkName?: string) { super(msg); this.name = "BenchmarkRunError"; this.benchmarkName = benchmarkName; }}
function red(text: string): string { return Deno.noColor ? text : `\x1b[31m${text}\x1b[0m`;}
function blue(text: string): string { return Deno.noColor ? text : `\x1b[34m${text}\x1b[0m`;}
function verifyOr1Run(runs?: number): number { return runs && runs >= 1 && runs !== Infinity ? Math.floor(runs) : 1;}
function assertTiming(clock: BenchmarkClock) { // NaN indicates that a benchmark has not been timed properly if (!clock.stop) { throw new BenchmarkRunError( `Running benchmarks FAILED during benchmark named [${clock.for}]. The benchmark timer's stop method must be called`, clock.for, ); } else if (!clock.start) { throw new BenchmarkRunError( `Running benchmarks FAILED during benchmark named [${clock.for}]. The benchmark timer's start method must be called`, clock.for, ); } else if (clock.start > clock.stop) { throw new BenchmarkRunError( `Running benchmarks FAILED during benchmark named [${clock.for}]. The benchmark timer's start method must be called before its stop method`, clock.for, ); }}
function createBenchmarkTimer(clock: BenchmarkClock): BenchmarkTimer { return { start() { clock.start = performance.now(); }, stop() { if (isNaN(clock.start)) { throw new BenchmarkRunError( `Running benchmarks FAILED during benchmark named [${clock.for}]. The benchmark timer's start method must be called before its stop method`, clock.for, ); } clock.stop = performance.now(); }, };}
const candidates: BenchmarkDefinition[] = [];
/** * @deprecated (will be removed after 0.157.0) Use `Deno.bench()` instead. See https://doc.deno.land/deno/unstable/~/Deno.bench * for details. * * Registers a benchmark as a candidate for the runBenchmarks executor. */export function bench( benchmark: BenchmarkDefinition | BenchmarkFunction,) { if (!benchmark.name) { throw new Error("The benchmark function must not be anonymous"); } if (typeof benchmark === "function") { candidates.push({ name: benchmark.name, runs: 1, func: benchmark }); } else { candidates.push({ name: benchmark.name, runs: verifyOr1Run(benchmark.runs), func: benchmark.func, }); }}
/** * Clears benchmark candidates which name matches `only` and doesn't match `skip`. * Removes all candidates if options were not provided. * * @deprecated (will be removed after 0.157.0) Use `Deno.bench()` instead. See: https://doc.deno.land/deno/unstable/~/Deno.bench * for details. */export function clearBenchmarks({ only = /[^\s]/, skip = /$^/,}: BenchmarkClearOptions = {}) { const keep = candidates.filter( ({ name }): boolean => !only.test(name) || skip.test(name), ); candidates.splice(0, candidates.length); candidates.push(...keep);}
/** * @deprecated (will be removed after 0.157.0) Use `Deno.bench()` instead. See https://doc.deno.land/deno/unstable/~/Deno.bench * for details. * * Runs all registered and non-skipped benchmarks serially. * * @param [progressCb] provides the possibility to get updates of the current progress during the run of the benchmarking * @returns results of the benchmarking */export async function runBenchmarks( { only = /[^\s]/, skip = /^\s*$/, silent }: BenchmarkRunOptions = {}, progressCb?: (progress: BenchmarkRunProgress) => void | Promise<void>,): Promise<BenchmarkRunResult> { // Filtering candidates by the "only" and "skip" constraint const benchmarks: BenchmarkDefinition[] = candidates.filter( ({ name }): boolean => only.test(name) && !skip.test(name), ); // Init main counters and error flag const filtered = candidates.length - benchmarks.length; let failError: Error | undefined = undefined; // Setting up a shared benchmark clock and timer const clock: BenchmarkClock = { start: NaN, stop: NaN }; const b = createBenchmarkTimer(clock);
// Init progress data const progress: BenchmarkRunProgress = { // bench.run is already ensured with verifyOr1Run on register queued: benchmarks.map((bench) => ({ name: bench.name, runsCount: bench.runs!, })), results: [], filtered, state: ProgressState.BenchmarkingStart, };
// Publish initial progress data await publishProgress(progress, ProgressState.BenchmarkingStart, progressCb);
if (!silent) { console.log( "running", benchmarks.length, `benchmark${benchmarks.length === 1 ? " ..." : "s ..."}`, ); }
// Iterating given benchmark definitions (await-in-loop) for (const { name, runs = 0, func } of benchmarks) { if (!silent) { // See https://github.com/denoland/deno/pull/1452 about groupCollapsed console.groupCollapsed(`benchmark ${name} ... `); }
// Provide the benchmark name for clock assertions clock.for = name;
// Remove benchmark from queued assert(progress.queued); const queueIndex = progress.queued.findIndex( (queued) => queued.name === name && queued.runsCount === runs, ); if (queueIndex != -1) { progress.queued.splice(queueIndex, 1); } // Init the progress of the running benchmark progress.running = { name, runsCount: runs, measuredRunsMs: [] }; // Publish starting of a benchmark await publishProgress(progress, ProgressState.BenchStart, progressCb);
// Trying benchmark.func let result = ""; try { // Averaging runs let pendingRuns = runs; let totalMs = 0;
// Would be better 2 not run these serially while (true) { // b is a benchmark timer interfacing an unset (NaN) benchmark clock await func(b); // Making sure the benchmark was started/stopped properly assertTiming(clock);
// Calculate length of run const measuredMs = clock.stop - clock.start;
// Summing up totalMs += measuredMs; // Adding partial result progress.running.measuredRunsMs.push(measuredMs); // Publish partial benchmark results await publishProgress( progress, ProgressState.BenchPartialResult, progressCb, );
// Resetting the benchmark clock clock.start = clock.stop = NaN; // Once all ran if (!--pendingRuns) { result = runs == 1 ? `${totalMs}ms` : `${runs} runs avg: ${totalMs / runs}ms`; // Adding results progress.results.push({ name, totalMs, runsCount: runs, measuredRunsAvgMs: totalMs / runs, measuredRunsMs: progress.running.measuredRunsMs, }); // Clear currently running delete progress.running; // Publish results of the benchmark await publishProgress( progress, ProgressState.BenchResult, progressCb, ); break; } } } catch (err) { if (err instanceof Error) { failError = err;
if (!silent) { console.groupEnd(); console.error(red(err.stack ?? "")); } }
break; }
if (!silent) { // Reporting console.log(blue(result)); console.groupEnd(); }
// Resetting the benchmark clock clock.start = clock.stop = NaN; delete clock.for; }
// Indicate finished running delete progress.queued; // Publish final result in Cb too await publishProgress(progress, ProgressState.BenchmarkingEnd, progressCb);
if (!silent) { // Closing results console.log( `benchmark result: ${failError ? red("FAIL") : blue("DONE")}. ` + `${progress.results.length} measured; ${filtered} filtered`, ); }
// Throw error if there was a failing benchmark if (failError) { throw failError; }
const benchmarkRunResult = { filtered, results: progress.results, };
return benchmarkRunResult;}
async function publishProgress( progress: BenchmarkRunProgress, state: ProgressState, progressCb?: (progress: BenchmarkRunProgress) => void | Promise<void>,) { progressCb && (await progressCb(cloneProgressWithState(progress, state)));}
function cloneProgressWithState( progress: BenchmarkRunProgress, state: ProgressState,): BenchmarkRunProgress { return deepAssign({}, progress, { state }) as BenchmarkRunProgress;}
std
Version Info
a year ago
