zbench-js 0.1.0 → 0.2.0

package/dist/runner.js

@@ -1,121 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-import { performance } from 'node:perf_hooks';
-import { pathToFileURL } from 'node:url';
-import { flagCombinations } from './config.js';
-/** `import()` the test module and check that it is one. */
-export async function loadTest(test) {
-    const module = (await import(pathToFileURL(test.file).href));
-    if (typeof module.test != 'function')
-        throw new Error(`${test.path} does not export a \`test\` function`);
-    return module;
-}
-/**
- * Time one configuration.
- * `setup`/`teardown` run once, `before`/`after` run around each iteration, and only `test` is timed.
- */
-async function runCase(module, test, flags, configuration, options) {
-    const config = { ...flags, ...configuration.value };
-    const iterations = options.iterations ?? test.iterations;
-    const warmup = options.warmup ?? test.warmup;
-    const result = {
-        test: test.id,
-        flags,
-        configuration: configuration.name,
-        value: configuration.value,
-        setup: 0,
-        samples: [],
-        amounts: {},
-    };
-    // By key, not by metric: a key with both a per-configuration and an aggregate metric is one quantity
-    const quantities = [...new Set(test.metrics.map(metric => metric.key))];
-    const setupStart = performance.now();
-    let state;
-    try {
-        state = await module.setup?.(config);
-    }
-    catch (e) {
-        result.error = `setup: ${e?.stack ?? e}`;
-        return result;
-    }
-    result.setup = performance.now() - setupStart;
-    try {
-        for (let i = 0; i < warmup + iterations; i++) {
-            const timed = i >= warmup;
-            await module.before?.(config, state);
-            globalThis.gc?.();
-            const start = performance.now();
-            const amounts = await module.test(config, state);
-            const elapsed = performance.now() - start;
-            await module.after?.(config, state);
-            if (!timed)
-                continue;
-            result.samples.push(elapsed);
-            for (const key of quantities) {
-                const amount = amounts?.[key] ?? configuration.value[key];
-                if (amount === undefined)
-                    continue;
-                result.amounts[key] = (result.amounts[key] ?? 0) + amount;
-            }
-        }
-    }
-    catch (e) {
-        result.error = String(e?.stack ?? e);
-    }
-    finally {
-        try {
-            await module.teardown?.(config, state);
-        }
-        catch (e) {
-            result.error ??= `teardown: ${e?.stack ?? e}`;
-        }
-    }
-    return result;
-}
-/** Whether a configuration fits in the budget, and why not when it doesn't. */
-export function skipReason(configuration, options) {
-    if (options.all)
-        return undefined;
-    if (options.cpu !== undefined && configuration.cpu > options.cpu)
-        return `needs cpu ${configuration.cpu}`;
-    if (options.mem !== undefined && configuration.mem > options.mem)
-        return `needs mem ${configuration.mem}`;
-    return undefined;
-}
-/** Narrow a test's flags to the values the caller asked for, dropping the rest. */
-function selectFlags(test, options) {
-    const flags = {};
-    for (const [name, values] of Object.entries(test.flags)) {
-        const wanted = options.flags?.[name];
-        flags[name] = wanted ? values.filter(v => wanted.some(w => Object.is(w, v))) : values;
-    }
-    return flagCombinations(flags);
-}
-/** Run every configuration of a test, once per flag combination. */
-export async function runTest(test, options = {}) {
-    const module = await loadTest(test);
-    const combinations = selectFlags(test, options);
-    const results = [];
-    const total = combinations.length * test.configurations.length;
-    let index = 0;
-    for (const flags of combinations) {
-        for (const configuration of test.configurations) {
-            options.onCase?.(test, flags, configuration.name, index++, total);
-            const skipped = skipReason(configuration, options);
-            if (skipped) {
-                results.push({
-                    test: test.id,
-                    flags,
-                    configuration: configuration.name,
-                    value: configuration.value,
-                    setup: 0,
-                    samples: [],
-                    amounts: {},
-                    skipped,
-                });
-                continue;
-            }
-            results.push(await runCase(module, test, flags, configuration, options));
-        }
-    }
-    return results;
-}