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"; /** * scale-architecture.md §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> = 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 { 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 { 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(); }