Files
clean-architecture-frontend…/scripts/scale/run-composition-scale.ts

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();
}