import {

benchmarkCreateIndex,

benchmarkPopulate,

benchmarkReadTransaction,

benchmarkScan,

benchmarkSingleByteWrite,

benchmarkWriteReadRoundTrip,

benchmarkSubscribe,

} from './replicache.js';

import {benchmarkIDBRead, benchmarkIDBWrite} from './idb.js';

/**

* @typedef {{

* name: string;

* group: string;

* byteSize?: number;

* setup?: () => Promise<void> | void;

* teardown?: () => Promise<void> | void;

* run: (b: Bencher, i: number) => Promise<void> | void;

* }} Benchmark

*

* @typedef {{

* reset: () => void;

* stop: () => void;

* }} Bencher

*

* @typedef {"benchmarkJS"|"replicache"} OutputFormat

*/

/**

* @param {Benchmark} benchmark

* @param {OutputFormat} format

*/

async function runBenchmark(benchmark, format) {

// Execute fn at least this many runs.

const minRuns = 5;

// Execute fn at least for this long.

const minTime = 500;

/** @type number[] */

const times = [];

let sum = 0;

if (benchmark.setup) {

await benchmark.setup();

}

for (let i = 0; i < minRuns || sum < minTime; i++) {

let t0 = performance.now();

let t1 = 0;

await benchmark.run(

{

reset() {

t0 = performance.now();

},

stop() {

t1 = performance.now();

},

},

i,

);

if (t1 == 0) {

t1 = performance.now();

}

const dur = t1 - t0;

times.push(dur);

sum += dur;

}

if (benchmark.teardown) {

await benchmark.teardown();

}

times.sort((a, b) => a - b);

const runs = times.length;

const median = 0.5;

const medianTime = times[Math.floor(runs * median)];

const bytesPerSecond = benchmark.byteSize

? `${formatToMBPerSecond(benchmark.byteSize, medianTime)} `

: '';

if (format == 'replicache') {

const ptiles = [median, 0.75, 0.9, 0.95];

return `${benchmark.name} ${ptiles

.map(p => String(p * 100))

.join('/')}%=${ptiles.map(p =>

times[Math.floor(runs * p)].toFixed(2),

)}ms/op ${bytesPerSecond}(${runs} runs sampled)`;

} else {

const variance =

Math.max(medianTime - times[0], times[times.length - 1] - medianTime) /

medianTime;

return formatAsBenchmarkJS({

name: benchmark.name,

value: bytesPerSecond || `${((runs / sum) * 1000).toFixed(2)} ops/sec `,

variance: `${(variance * 100).toFixed(1)}%`,

runs,

});

}

}

/**

* @param {{name: string; value: string; variance: string; runs: number}} opts

*/

function formatAsBenchmarkJS({name, value, variance, runs}) {

// Example:

// fib(20) x 11,465 ops/sec ±1.12% (91 runs sampled)

// createObjectBuffer with 200 comments x 81.61 ops/sec ±1.70% (69 runs sampled)

return `${name} x ${value}±${variance} (${runs} runs sampled)`;

}

/**

* @param {number} size

* @param {number} timeMS

*/

function formatToMBPerSecond(size, timeMS) {

const bytes = (size / timeMS) * 1000;

return (bytes / 2 ** 20).toFixed(2) + ' MB/s';

}

const benchmarks = [

benchmarkPopulate({numKeys: 1000, clean: true}),

benchmarkPopulate({numKeys: 1000, clean: false}),

benchmarkPopulate({numKeys: 1000, clean: true, indexes: 1}),

benchmarkPopulate({numKeys: 1000, clean: true, indexes: 2}),

benchmarkReadTransaction({numKeys: 1000}),

benchmarkReadTransaction({numKeys: 5000}),

benchmarkScan({numKeys: 1000}),

benchmarkScan({numKeys: 5000}),

benchmarkSingleByteWrite(),

benchmarkWriteReadRoundTrip(),

benchmarkCreateIndex({numKeys: 1000}),

benchmarkCreateIndex({numKeys: 5000}),

benchmarkSubscribe({count: 10}),

benchmarkSubscribe({count: 100}),

benchmarkSubscribe({count: 1000}),

];

for (let b of [benchmarkIDBRead, benchmarkIDBWrite]) {

for (let numKeys of [1, 10, 100, 1000]) {

const dataTypes = /** @type {import('./data').RandomDataType[]} */ (

/** @type unknown */ (['string', 'object', 'arraybuffer'])

);

for (let dataType of dataTypes) {

const kb = 1024;

const mb = kb * kb;

const sizes = [

kb,

32 * kb,

// Note: on blink, as of 4/2/2021, there's a cliff at 64kb

mb,

10 * mb,

100 * mb,

];

const group = dataType == 'arraybuffer' ? 'idb' : 'idb-extras';

for (let valSize of sizes) {

if (valSize > 10 * mb) {

if (numKeys > 1) {

continue;

}

} else if (valSize >= mb) {

if (numKeys > 10) {

continue;

}

}

benchmarks.push(b({group, dataType, numKeys, valSize}));

}

}

}

}

let current = 0;

/**

* @param {string[]} groups

* @param {OutputFormat} format

*/

async function nextTest(groups, format) {

while (current < benchmarks.length) {

const b = benchmarks[current++];

if (groups.includes(b.group)) {

try {

return await runBenchmark(b, format);

} catch (e) {

return `${b.name}: Error: ${e}`;

}

}

}

return null;

}

// @ts-ignore

window.nextTest = nextTest;

// @ts-ignore

window.benchmarks = benchmarks;

// @ts-ignore

window.runAll = async function (groups) {

current = 0;

const out = /** @type {HTMLPreElement} */ (

/** @type {unknown} */ document.getElementById('out')

);

for (;;) {

const r = await nextTest(groups, 'replicache');

if (r == null) {

break;

}

out.textContent += r + '\n';

}

out.textContent += 'Done!\n';

};