Files
clean-architecture-frontend…/scripts/scale/memory-slope.ts
T

67 lines
2.8 KiB
TypeScript

/**
* Spec §44. Soak classification.
*
* The leak signal is sustained positive growth after warm-up, not an
* arbitrary absolute maximum. The classifier fits a least-squares line over
* the post-warm-up samples and reports `unbounded-growth` only when both the
* slope and the total relative growth are material.
*/
export type SlopeSample = Readonly<{ minute: number; heapMb: number }>;
export type MemorySlopeClass = "stable" | "unbounded-growth" | "insufficient-data";
export type MemorySlopeOptions = Readonly<{
/** Samples before this minute are warm-up. Default 0. */
warmupMinutes?: number;
/** Largest tolerated post-warm-up slope in MB per minute. Default 0.5. */
maxSlopeMbPerMinute?: number;
/** Largest tolerated relative growth first->last fitted value. Default 0.1. */
maxRelativeGrowth?: number;
}>;
export function linearSlope(points: readonly Readonly<{ x: number; y: number }>[]): number {
const count = points.length;
if (count < 2) return 0;
const meanX = points.reduce((sum, point) => sum + point.x, 0) / count;
const meanY = points.reduce((sum, point) => sum + point.y, 0) / count;
let numerator = 0;
let denominator = 0;
for (const point of points) {
numerator += (point.x - meanX) * (point.y - meanY);
denominator += (point.x - meanX) ** 2;
}
return denominator === 0 ? 0 : numerator / denominator;
}
export function classifyMemorySlope(
samples: readonly SlopeSample[],
options: MemorySlopeOptions = {},
): MemorySlopeClass {
const warmup = options.warmupMinutes ?? 0;
const maxSlope = options.maxSlopeMbPerMinute ?? 0.5;
const maxGrowth = options.maxRelativeGrowth ?? 0.1;
const measured = samples
.filter((sample) => sample.minute >= warmup)
.filter((sample) => Number.isFinite(sample.minute) && Number.isFinite(sample.heapMb))
.sort((left, right) => left.minute - right.minute);
if (measured.length < 3) return "insufficient-data";
const slope = linearSlope(measured.map((sample) => ({ x: sample.minute, y: sample.heapMb })));
const first = measured[0] as SlopeSample;
const last = measured[measured.length - 1] as SlopeSample;
const fittedStart = Math.max(first.heapMb, Number.MIN_VALUE);
const growth = (slope * (last.minute - first.minute)) / fittedStart;
return slope > maxSlope && growth > maxGrowth ? "unbounded-growth" : "stable";
}
/** Generic variant for logical counters (timers, listeners, buffered events). */
export function classifyCounterSeries(
values: readonly number[],
options: Readonly<{ warmupSamples?: number; maxSlopePerSample?: number }> = {},
): MemorySlopeClass {
const warmup = options.warmupSamples ?? 0;
const measured = values.slice(warmup);
if (measured.length < 3) return "insufficient-data";
const slope = linearSlope(measured.map((y, x) => ({ x, y })));
return slope > (options.maxSlopePerSample ?? 0.01) ? "unbounded-growth" : "stable";
}