/* eslint-disable @typescript-eslint/ban-ts-comment */

// @ts-check

/* eslint-env browser, es2020 */

import {Replicache} from '../out/replicache.mjs';

console.assert = console.debug = console.error = console.info = console.log = console.warn = () =>

void 0;

const valSize = 1024;

/**

* @template R

* @returns {{promise: Promise<R>, resolve: (res: R) => void}}

*/

function resolver() {

let resolve;

const promise = new Promise(res => {

resolve = res;

});

return {promise, resolve};

}

/**

* @param {number} len

*/

function randomString(len) {

const arr = new Uint8Array(len);

crypto.getRandomValues(arr);

for (let i = 0; i < len; i++) {

// Don't allow \0 in the string because these values are used as secondary

// keys when building indexes and we do not allow \0 there so it slows down

// the benchmark.

if (arr[i] === 0) {

arr[i] = 1;

}

}

return new TextDecoder('ascii').decode(arr);

}

/**

* @param {number} length

*/

function makeRandomStrings(length) {

return Array.from({length}, () => randomString(valSize));

}

/**

* @param {string} name

*/

function deleteDatabase(name) {

return new Promise((resolve, reject) => {

const req = indexedDB.deleteDatabase(name);

req.onsuccess = resolve;

req.onerror = req.onblocked = req.onupgradeneeded = reject;

});

}

let counter = 0;

async function makeRep() {

const name = `bench${counter++}`;

await deleteDatabase(name);

return new Replicache({

name,

pullInterval: null,

});

}

/**

* @param {Replicache} rep

* @param {{numKeys: number}}

* @param {string[]} randomStrings

*/

async function populate(rep, {numKeys}, randomStrings) {

const set = rep.register('populate', async tx => {

for (let i = 0; i < numKeys; i++) {

await tx.put(`key${i}`, randomStrings[i]);

}

});

await set();

}

/**

* @param {Bench} bench

* @param {{numKeys: number; clean: boolean; indexes?: number;}} opts

*/

async function benchmarkPopulate(bench, opts) {

const rep = await makeRep();

if (!opts.clean) {

await populate(rep, opts, makeRandomStrings(opts.numKeys));

}

for (let i = 0; i < opts.indexes || 0; i++) {

await rep.createIndex({

name: `idx${i}`,

jsonPointer: '',

});

}

const randomStrings = makeRandomStrings(opts.numKeys);

bench.reset();

bench.name = `populate ${valSize}x${opts.numKeys} (${

opts.clean ? 'clean' : 'dirty'

}, ${`indexes: ${opts.indexes || 0}`})`;

bench.size = opts.numKeys * valSize;

await populate(rep, opts, randomStrings);

bench.stop();

await rep.close();

}

/** @typedef {{

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

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

* name: string;

* size: number;

* reset: () => void;

* stop: () => void;

* formatter: (size: number, timeMS: number) => string;

* }}

*/

// eslint-disable-next-line @typescript-eslint/no-unused-vars

let Bench;

/** @type {Replicache} */

let rep;

async function benchmarkReadTransaction(bench, opts) {

await bench.setup(async () => {

bench.name = `read tx ${valSize}x${opts.numKeys}`;

bench.size = opts.numKeys * valSize;

rep = await makeRep();

await populate(rep, opts, makeRandomStrings(opts.numKeys));

});

bench.teardown = async () => {

await rep.close();

};

await populate(rep, opts, makeRandomStrings(opts.numKeys));

bench.reset();

await rep.query(async tx => {

let getCount = 0;

let hasCount = false;

for (let i = 0; i < opts.numKeys; i++) {

// use the values to be confident we're not optimizing away.

// @ts-ignore

getCount += (await tx.get(`key${i}`)).length;

// @ts-ignore

hasCount = (await tx.has(`key${i}`)) === true ? 1 : 0;

}

console.log(getCount, hasCount);

});

bench.stop();

}

/**

* @param {Bench} bench

* @param {{numKeys: number;}} opts

*/

async function benchmarkScan(bench, opts) {

await bench.setup(async () => {

bench.name = `scan ${valSize}x${opts.numKeys}`;

bench.size = opts.numKeys * valSize;

rep = await makeRep();

await populate(rep, opts, makeRandomStrings(opts.numKeys));

});

bench.teardown = async () => {

await rep.close();

};

bench.reset();

await rep.query(async tx => {

let count = 0;

for await (const value of tx.scan()) {

// use the value to be confident we're not optimizing away.

// @ts-ignore

count += value.length;

}

console.log(count);

});

bench.stop();

}

/**

* @param {Bench} bench

* @param {number} i

*/

async function benchmarkSingleByteWrite(bench, i) {

const rep = await makeRep();

const write = rep.register('write', tx => tx.put('k', i % 10));

bench.name = 'write single byte';

bench.size = 1;

bench.formatter = formatTxPerSecond;

bench.reset();

await write();

bench.stop();

await rep.close();

}

/**

* @param {Bench} bench

* @param {{numKeys: number;}} opts

*/

async function createIndex(bench, opts) {

const rep = await makeRep();

await populate(rep, opts, makeRandomStrings(opts.numKeys));

bench.name = `create index ${valSize}x${opts.numKeys}`;

bench.size = 1;

bench.formatter = formatOpPerSecond;

bench.reset();

await rep.createIndex({

name: `idx`,

jsonPointer: '',

});

bench.stop();

await rep.close();

}

/**

* @param {Bench} bench

* @param {number} i

*/

async function benchmarkWriteReadRoundTrip(bench, i) {

await bench.setup(async () => {

rep = await makeRep();

});

bench.teardown = async () => {

await rep.close();

};

const key = `k${i}`;

const value = i;

let {promise, resolve} = resolver();

const unsubscribe = rep.subscribe(tx => tx.get(key), {

onData(res) {

// `resolve` binding needs to be looked up on every iteration

resolve(res);

},

});

// onData is called once when calling subscribe

await promise;

const write = rep.register('write', tx => tx.put(key, value));

bench.name = 'roundtrip write/subscribe/get';

bench.size = 1;

bench.formatter = formatOpPerSecond;

bench.reset();

// reset these.

({promise, resolve} = resolver());

await write();

const res = await promise;

if (res !== value) {

throw new Error();

}

bench.stop();

unsubscribe();

}

/**

* @param {(bench: Bench, i: number) => void | Promise<void>} fn

*/

async function benchmark(fn) {

// Execute fn at least this many runs.

const minRuns = 5;

// Execute fn at least for this long.

const minTime = 2000;

const times = [];

let sum = 0;

let name = String(fn);

let size = 0;

let format = formatToMBPerSecond;

let setupCalled = false;

/** @type {(() => Promise<void> | void) | undefined} */

let teardown;

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

let t0 = performance.now();

let t1 = 0;

await fn(

{

reset() {

t0 = performance.now();

},

stop() {

t1 = performance.now();

},

/**

* @param {string} n

*/

set name(n) {

name = n;

},

/**

* @param {number} s

*/

set size(s) {

size = s;

},

/**

* @return {number} s

*/

get size() {

return size;

},

/**

* @param {(size: number, timeMS: number) => string} f

*/

set formatter(f) {

format = f;

},

/**

* @param {() => void | Promise<void>} f

*/

async setup(f) {

if (!setupCalled) {

await f();

setupCalled = true;

}

},

/**

* @param {() => (Promise<void> | void) } f

*/

set teardown(f) {

teardown = f;

},

},

i,

);

if (t1 == 0) {

t1 = performance.now();

}

const dur = t1 - t0;

times.push(dur);

sum += dur;

}

if (teardown) {

await teardown();

}

console.log(sum);

times.sort();

const runs = times.length;

const median = times[Math.floor(runs / 2)];

const value = format(size, median);

return {name, value, median, runs};

}

/**

* @param {number} size

* @param {number} timeMS

*/

function formatToMBPerSecond(size, timeMS) {

const bytes = (size / timeMS) * 1000;

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

}

/**

* @param {string} x

* @return {(size: number, timeMS: number) => string}

*/

function makeFormatXPerSecond(x) {

return (size, timeMS) => `${((size / timeMS) * 1000).toFixed(2)} ${x}/s`;

}

const formatTxPerSecond = makeFormatXPerSecond('tx');

const formatOpPerSecond = makeFormatXPerSecond('op');

const benchmarks = [

bench => benchmarkPopulate(bench, {numKeys: 1000, clean: true}),

bench => benchmarkPopulate(bench, {numKeys: 1000, clean: false}),

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

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

bench => benchmarkReadTransaction(bench, {numKeys: 1000}),

bench => benchmarkReadTransaction(bench, {numKeys: 5000}),

bench => benchmarkScan(bench, {numKeys: 1000}),

bench => benchmarkScan(bench, {numKeys: 5000}),

benchmarkSingleByteWrite,

benchmarkWriteReadRoundTrip,

bench => createIndex(bench, {numKeys: 1000}),

bench => createIndex(bench, {numKeys: 5000}),

];

let current = 0;

async function nextTest() {

if (current < benchmarks.length) {

return await benchmark(benchmarks[current++]);

}

return null;

}

// @ts-ignore

window.nextTest = nextTest;