overtake 2.0.0 → 2.0.1

package/build/register-hook.js

@@ -0,0 +1,15 @@
+import { register } from 'node:module';
+async function resolve(s, c, n) {
+    try {
+        return await n(s, c);
+    }
+    catch (e) {
+        if (s.endsWith('.js'))
+            try {
+                return await n(s.slice(0, -3) + '.ts', c);
+            }
+            catch { }
+        throw e;
+    }
+}
+register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));

package/build/reporter.d.ts

@@ -1,4 +1,4 @@
-import { type ReportType } from './types.ts';
+import { type ReportType } from './types.js';
 export declare class Report {
     readonly type: ReportType;
     readonly value: bigint;

package/build/reporter.js

@@ -0,0 +1,255 @@
+import { div, max, divs, isqrt } from './utils.js';
+import { DURATION_SCALE } from './types.js';
+const units = [
+    { unit: 'ns', factor: 1 },
+    { unit: 'µs', factor: 1e3 },
+    { unit: 'ms', factor: 1e6 },
+    { unit: 's', factor: 1e9 },
+    { unit: 'm', factor: 60 * 1e9 },
+    { unit: 'h', factor: 3600 * 1e9 },
+];
+function smartFixed(n) {
+    return n.toLocaleString(undefined, {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2,
+        useGrouping: true,
+    });
+}
+export class Report {
+    type;
+    value;
+    uncertainty;
+    scale;
+    constructor(type, value, uncertainty = 0, scale = 1n) {
+        this.type = type;
+        this.value = value;
+        this.uncertainty = uncertainty;
+        this.scale = scale;
+    }
+    valueOf() {
+        return Number(div(this.value, this.scale));
+    }
+    toString() {
+        const uncertainty = this.uncertainty ? ` ± ${smartFixed(this.uncertainty)}%` : '';
+        const value = this.valueOf();
+        if (this.type === 'ops') {
+            return `${smartFixed(value)} ops/s${uncertainty}`;
+        }
+        if (this.type === 'rme') {
+            return `${smartFixed(value)}%`;
+        }
+        if (this.type === 'variance') {
+            let display = value;
+            let unit = 'ns²';
+            const varianceUnits = [
+                { unit: 'ns²', factor: 1 },
+                { unit: 'µs²', factor: 1e6 },
+                { unit: 'ms²', factor: 1e12 },
+            ];
+            for (const { unit: u, factor } of varianceUnits) {
+                const candidate = value / factor;
+                if (candidate < 1000) {
+                    display = candidate;
+                    unit = u;
+                    break;
+                }
+            }
+            return `${smartFixed(display)} ${unit}`;
+        }
+        let display = value;
+        let unit = 'ns';
+        for (const { unit: u, factor } of units) {
+            const candidate = value / factor;
+            if (candidate < 1000) {
+                display = candidate;
+                unit = u;
+                break;
+            }
+        }
+        return `${smartFixed(display)} ${unit}${uncertainty}`;
+    }
+}
+const SQRT_SCALE = 1000000n;
+const SQRT_SCALE_SQ = SQRT_SCALE * SQRT_SCALE;
+const Z95_NUM = 196n;
+const Z95_DENOM = 100n;
+export const computeStats = (durations) => {
+    let sum = 0n;
+    for (const d of durations)
+        sum += d;
+    const n = BigInt(durations.length);
+    const mean = sum / n;
+    let ssd = 0n;
+    for (const d of durations) {
+        const diff = d - mean;
+        ssd += diff * diff;
+    }
+    return { sum, mean, ssd, n };
+};
+export const createReport = (durations, type, stats) => {
+    const n = durations.length;
+    if (n === 0) {
+        return new Report(type, 0n);
+    }
+    const st = stats ?? computeStats(durations);
+    switch (type) {
+        case 'min': {
+            return new Report(type, durations[0], 0, DURATION_SCALE);
+        }
+        case 'max': {
+            return new Report(type, durations[n - 1], 0, DURATION_SCALE);
+        }
+        case 'median': {
+            const mid = Math.floor(n / 2);
+            const med = n % 2 === 0 ? (durations[mid - 1] + durations[mid]) / 2n : durations[mid];
+            return new Report(type, med, 0, DURATION_SCALE);
+        }
+        case 'mode': {
+            const freq = new Map();
+            let maxCount = 0n;
+            let modeVal = durations[0];
+            for (const d of durations) {
+                const count = (freq.get(d) || 0n) + 1n;
+                freq.set(d, count);
+                if (count > maxCount) {
+                    maxCount = count;
+                    modeVal = d;
+                }
+            }
+            let lower = modeVal;
+            let upper = modeVal;
+            const firstIdx = durations.indexOf(modeVal);
+            const lastIdx = durations.lastIndexOf(modeVal);
+            if (firstIdx > 0)
+                lower = durations[firstIdx - 1];
+            if (lastIdx < n - 1)
+                upper = durations[lastIdx + 1];
+            const gap = max(modeVal - lower, upper - modeVal);
+            const uncertainty = modeVal > 0 ? Number(((gap / 2n) * 100n) / modeVal) : 0;
+            return new Report(type, modeVal, uncertainty, DURATION_SCALE);
+        }
+        case 'ops': {
+            const { mean: avgScaled, ssd, n: nBig } = st;
+            const nsPerSecScaled = 1000000000n * DURATION_SCALE;
+            const raw = Number(nsPerSecScaled) / Number(avgScaled);
+            const extra = raw < 1 ? Math.ceil(-Math.log10(raw)) : 0;
+            const exp = raw > 100 ? 0 : 2 + extra;
+            const scale = 10n ** BigInt(exp);
+            const value = avgScaled > 0n ? (nsPerSecScaled * scale) / avgScaled : 0n;
+            let uncertainty = 0;
+            if (n >= 2 && avgScaled > 0n) {
+                const RME_PRECISION = 1000000n;
+                const semOverMeanSqScaled = (ssd * RME_PRECISION * RME_PRECISION) / (BigInt(n - 1) * nBig * avgScaled * avgScaled);
+                const semOverMeanScaled = isqrt(semOverMeanSqScaled);
+                uncertainty = Number(Z95_NUM * semOverMeanScaled) / Number(RME_PRECISION);
+            }
+            return new Report(type, value, uncertainty, scale);
+        }
+        case 'mean': {
+            const { sum } = st;
+            const value = divs(sum, BigInt(n), 1n);
+            return new Report(type, value, 0, DURATION_SCALE);
+        }
+        case 'variance': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE * DURATION_SCALE);
+            const { ssd } = st;
+            const variance = ssd / BigInt(n - 1);
+            return new Report(type, variance, 0, DURATION_SCALE * DURATION_SCALE);
+        }
+        case 'sd': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd } = st;
+            const scaledVariance = (ssd * SQRT_SCALE_SQ) / BigInt(n - 1);
+            const sdScaled = isqrt(scaledVariance);
+            return new Report(type, sdScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'sem': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            return new Report(type, semScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'moe': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            return new Report(type, moeScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'rme': {
+            if (n < 2)
+                return new Report(type, 0n);
+            const { mean, ssd, n: nBig } = st;
+            if (mean === 0n)
+                return new Report(type, 0n);
+            const RME_PRECISION = 1000000n;
+            const semOverMeanSqScaled = (ssd * RME_PRECISION * RME_PRECISION) / (BigInt(n - 1) * nBig * mean * mean);
+            const semOverMeanScaled = isqrt(semOverMeanSqScaled);
+            const rmeScaled = (Z95_NUM * semOverMeanScaled * 100n) / RME_PRECISION;
+            return new Report(type, rmeScaled, 0, 100n);
+        }
+        case 'mad': {
+            const medianIdx = Math.floor(n / 2);
+            const median = n % 2 === 1 ? durations[medianIdx] : (durations[medianIdx - 1] + durations[medianIdx]) / 2n;
+            const deviations = new BigUint64Array(n);
+            for (let i = 0; i < n; i++) {
+                const diff = durations[i] > median ? durations[i] - median : median - durations[i];
+                deviations[i] = diff;
+            }
+            deviations.sort();
+            const madIdx = Math.floor(n / 2);
+            const mad = n % 2 === 1 ? deviations[madIdx] : (deviations[madIdx - 1] + deviations[madIdx]) / 2n;
+            return new Report(type, mad, 0, DURATION_SCALE);
+        }
+        case 'iqr': {
+            const q1Idx = Math.floor(n * 0.25);
+            const q3Idx = Math.floor(n * 0.75);
+            const q1 = durations[q1Idx];
+            const q3 = durations[q3Idx];
+            const iqr = q3 - q1;
+            return new Report(type, iqr, 0, DURATION_SCALE);
+        }
+        case 'ci_lower': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { mean, ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            const ciLowerScaled = mean * SQRT_SCALE - moeScaled;
+            return new Report(type, ciLowerScaled > 0n ? ciLowerScaled : 0n, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'ci_upper': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { mean, ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            const ciUpperScaled = mean * SQRT_SCALE + moeScaled;
+            return new Report(type, ciUpperScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        default: {
+            const p = Number(type.slice(1));
+            if (p === 0) {
+                return new Report(type, durations[0], 0, DURATION_SCALE);
+            }
+            if (p === 100) {
+                return new Report(type, durations[n - 1], 0, DURATION_SCALE);
+            }
+            const idx = Math.ceil((p / 100) * n) - 1;
+            const value = durations[Math.min(Math.max(idx, 0), n - 1)];
+            const prev = idx > 0 ? durations[idx - 1] : value;
+            const next = idx < n - 1 ? durations[idx + 1] : value;
+            const gap = max(value - prev, next - value);
+            const uncertainty = value > 0 ? Number(div(divs(gap, 2n, 10000n), value)) / 100 : 0;
+            return new Report(type, value, uncertainty, DURATION_SCALE);
+        }
+    }
+};

package/build/runner.d.ts

@@ -1,2 +1,2 @@
-import { type Options } from './types.ts';
+import { type Options } from './types.js';
 export declare const benchmark: <TContext, TInput>({ setup, teardown, pre, run: runRaw, post, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver, durationsSAB, controlSAB, }: Required<Options<TContext, TInput>>) => Promise<number>;