137 lines
4.6 KiB
TypeScript
137 lines
4.6 KiB
TypeScript
import { resolve } from "node:path";
|
|
|
|
import {
|
|
assertLinearOrBetter,
|
|
growthExponents,
|
|
} from "../../src/platform/cardinality/growth-regression.ts";
|
|
import { benchmark } from "./benchmark.ts";
|
|
import {
|
|
writeBenchmarkArtifact,
|
|
type BenchmarkProfile,
|
|
type BenchmarkResult,
|
|
} from "./benchmark-result.ts";
|
|
import { COMPOSITION_WORKLOADS } from "./composition-workloads.ts";
|
|
|
|
/**
|
|
* Spec §36 / §39. Runtime composition scale gate for S0-S2.
|
|
*
|
|
* Every production composition workload runs at each requested profile with
|
|
* warm-up and repeated samples; the median series must be linear-or-better.
|
|
* Results are written as a machine-readable artifact under artifacts/scale/.
|
|
*/
|
|
export const COMPOSITION_PROFILES: Readonly<Record<string, number>> = Object.freeze({
|
|
S0: 100,
|
|
S1: 1_000,
|
|
S2: 10_000,
|
|
});
|
|
|
|
/** Scheduler noise below this median is not evidence of growth. */
|
|
export const COMPOSITION_NOISE_FLOOR_MS = 0.5;
|
|
/**
|
|
* n log n paths (sorting, allocation-heavy string work) measure ~1.1-1.4
|
|
* between S1 and S2; a quadratic path measures ~2. 1.6 separates the two.
|
|
*/
|
|
export const COMPOSITION_MAX_EXPONENT = 1.6;
|
|
|
|
export type CompositionScaleReport = Readonly<{
|
|
passed: boolean;
|
|
results: readonly BenchmarkResult[];
|
|
checks: readonly Readonly<{ name: string; passed: boolean; detail: string }>[];
|
|
}>;
|
|
|
|
export async function runCompositionScale(
|
|
profiles: readonly string[],
|
|
options: Readonly<{
|
|
samples?: number;
|
|
warmup?: number;
|
|
/**
|
|
* `median` (default) for standalone gate runs. `min` (best observed) when
|
|
* the gate shares the machine with other suites: stolen CPU and foreign
|
|
* GC only ever add time, so the minimum keeps the algorithmic shape.
|
|
*/
|
|
statistic?: "median" | "min";
|
|
}> = {},
|
|
): Promise<CompositionScaleReport> {
|
|
const results: BenchmarkResult[] = [];
|
|
const checks: { name: string; passed: boolean; detail: string }[] = [];
|
|
for (const workload of COMPOSITION_WORKLOADS) {
|
|
const series: { n: number; cost: number }[] = [];
|
|
for (const profile of profiles) {
|
|
const cardinality = COMPOSITION_PROFILES[profile];
|
|
if (cardinality === undefined) throw new TypeError(`unknown profile ${profile}`);
|
|
const run = workload.prepare(cardinality);
|
|
const result = await benchmark(workload.name, {
|
|
samples: options.samples ?? 7,
|
|
warmup: options.warmup ?? 2,
|
|
profile: profile as BenchmarkProfile,
|
|
cardinality,
|
|
measureHeap: true,
|
|
metadata: { implementation: workload.implementation },
|
|
run,
|
|
});
|
|
results.push(result);
|
|
series.push({
|
|
n: cardinality,
|
|
cost:
|
|
options.statistic === "min" ? Math.min(...result.samples) : result.medianMs,
|
|
});
|
|
}
|
|
if (series.length < 2) continue;
|
|
try {
|
|
assertLinearOrBetter(series, {
|
|
maxExponent: COMPOSITION_MAX_EXPONENT,
|
|
noiseFloor: COMPOSITION_NOISE_FLOOR_MS,
|
|
});
|
|
checks.push({
|
|
name: `${workload.name}:growth`,
|
|
passed: true,
|
|
detail: `exponents ${growthExponents(series, COMPOSITION_NOISE_FLOOR_MS)
|
|
.map((exponent) => exponent.toFixed(2))
|
|
.join(", ")}`,
|
|
});
|
|
} catch (error) {
|
|
checks.push({
|
|
name: `${workload.name}:growth`,
|
|
passed: false,
|
|
detail: error instanceof Error ? error.message : String(error),
|
|
});
|
|
}
|
|
}
|
|
return Object.freeze({
|
|
passed: checks.every((check) => check.passed),
|
|
results: Object.freeze(results),
|
|
checks: Object.freeze(checks),
|
|
});
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
const profileArg = process.argv.find((argument) => argument.startsWith("--profiles="));
|
|
const artifactArg = process.argv.find((argument) => argument.startsWith("--artifact="));
|
|
const profiles = (profileArg?.slice("--profiles=".length) ?? "S0,S1,S2")
|
|
.split(",")
|
|
.map((entry) => entry.trim())
|
|
.filter(Boolean);
|
|
const artifact = resolve(
|
|
artifactArg?.slice("--artifact=".length) ?? "artifacts/scale/composition-scale.json",
|
|
);
|
|
const report = await runCompositionScale(profiles);
|
|
await writeBenchmarkArtifact(artifact, {
|
|
schemaVersion: 1,
|
|
suite: "composition-scale",
|
|
generatedAt: new Date().toISOString(),
|
|
node: process.version,
|
|
passed: report.passed,
|
|
results: report.results,
|
|
checks: report.checks,
|
|
});
|
|
for (const check of report.checks) {
|
|
process.stdout.write(`${check.passed ? "PASS" : "FAIL"} ${check.name} (${check.detail})\n`);
|
|
}
|
|
process.stdout.write(`composition scale artifact: ${artifact}\n`);
|
|
if (!report.passed) process.exitCode = 1;
|
|
}
|
|
|
|
if (import.meta.url === `file://${process.argv[1]}`) {
|
|
await main();
|
|
}
|