test profile 300 NPC unification memory

2026-07-28 05:46:16 +00:00
parent 43966ea1ef
commit 431d3afc42
5 changed files with 443 additions and 7 deletions
@@ -0,0 +1,206 @@
+import { performance } from 'node:perf_hooks';
+import { serialize } from 'node:v8';
+
+import type { InMemoryReservedTurnStore } from '../../src/turn/reservedTurnStore.js';
+import type { InMemoryTurnWorld } from '../../src/turn/inMemoryWorld.js';
+
+type MemoryUsageSnapshot = {
+    rssBytes: number;
+    heapTotalBytes: number;
+    heapUsedBytes: number;
+    externalBytes: number;
+    arrayBuffersBytes: number;
+};
+
+export type NpcUnificationMemorySample = {
+    label: string;
+    year: number;
+    month: number;
+    activeNationCount: number;
+    generalCount: number;
+    cityCount: number;
+    troopCount: number;
+    processBeforeSnapshot: MemoryUsageSnapshot;
+    processWithSnapshot: MemoryUsageSnapshot;
+    processAfterRelease: MemoryUsageSnapshot;
+    worldSnapshotBytes: number;
+    reservedTurnSnapshotBytes: number;
+    totalParticipantSnapshotBytes: number;
+    participantSnapshotCloneMs: number;
+};
+
+type TickObservation = {
+    heapUsedBytes: number;
+    rssBytes: number;
+};
+
+const readMemoryUsage = (): MemoryUsageSnapshot => {
+    const usage = process.memoryUsage();
+    return {
+        rssBytes: usage.rss,
+        heapTotalBytes: usage.heapTotal,
+        heapUsedBytes: usage.heapUsed,
+        externalBytes: usage.external,
+        arrayBuffersBytes: usage.arrayBuffers,
+    };
+};
+
+const percentile = (values: number[], ratio: number): number => {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1));
+    return sorted[index] ?? 0;
+};
+
+const average = (values: number[]): number =>
+    values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
+
+export class NpcUnificationMemoryProfiler {
+    private readonly samples: NpcUnificationMemorySample[] = [];
+    private readonly tickObservations: TickObservation[] = [];
+
+    constructor(
+        private readonly world: InMemoryTurnWorld,
+        private readonly reservedTurns: InMemoryReservedTurnStore
+    ) {}
+
+    observeTick(): void {
+        const usage = readMemoryUsage();
+        this.tickObservations.push({
+            heapUsedBytes: usage.heapUsedBytes,
+            rssBytes: usage.rssBytes,
+        });
+    }
+
+    sample(label: string): NpcUnificationMemorySample {
+        globalThis.gc?.();
+        const processBeforeSnapshot = readMemoryUsage();
+        const snapshotMetrics = (() => {
+            const startedAt = performance.now();
+            const worldSnapshot = this.world.captureState();
+            const reservedTurnSnapshot = this.reservedTurns.captureState();
+            return {
+                participantSnapshotCloneMs: performance.now() - startedAt,
+                processWithSnapshot: readMemoryUsage(),
+                worldSnapshotBytes: serialize(worldSnapshot).byteLength,
+                reservedTurnSnapshotBytes: serialize(reservedTurnSnapshot).byteLength,
+            };
+        })();
+        globalThis.gc?.();
+        const processAfterRelease = readMemoryUsage();
+
+        const state = this.world.getState();
+        const cities = this.world.listCities();
+        const nations = this.world.listNations();
+        const sample: NpcUnificationMemorySample = {
+            label,
+            year: state.currentYear,
+            month: state.currentMonth,
+            activeNationCount: nations.filter(
+                (nation) => nation.level > 0 && cities.some((city) => city.nationId === nation.id)
+            ).length,
+            generalCount: this.world.listGenerals().length,
+            cityCount: cities.length,
+            troopCount: this.world.listTroops().length,
+            processBeforeSnapshot,
+            processWithSnapshot: snapshotMetrics.processWithSnapshot,
+            processAfterRelease,
+            worldSnapshotBytes: snapshotMetrics.worldSnapshotBytes,
+            reservedTurnSnapshotBytes: snapshotMetrics.reservedTurnSnapshotBytes,
+            totalParticipantSnapshotBytes:
+                snapshotMetrics.worldSnapshotBytes + snapshotMetrics.reservedTurnSnapshotBytes,
+            participantSnapshotCloneMs: snapshotMetrics.participantSnapshotCloneMs,
+        };
+        this.samples.push(sample);
+        return sample;
+    }
+
+    buildReport(input: {
+        startedAtMs: number;
+        initialGeneralCount: number;
+        foundedNationCount: number;
+        declarationCount: number;
+        sortieCount: number;
+        unifiedAt: { year: number; month: number };
+        startYear: number;
+        startMonth: number;
+    }) {
+        const cloneTimes = this.samples.map((sample) => sample.participantSnapshotCloneMs);
+        const snapshotSizes = this.samples.map((sample) => sample.totalParticipantSnapshotBytes);
+        const retainedSnapshotHeapDeltas = this.samples.map(
+            (sample) =>
+                sample.processWithSnapshot.heapUsedBytes - sample.processBeforeSnapshot.heapUsedBytes
+        );
+        const releasedSnapshotHeapDeltas = this.samples.map(
+            (sample) =>
+                sample.processAfterRelease.heapUsedBytes - sample.processBeforeSnapshot.heapUsedBytes
+        );
+        const observedHeap = [
+            ...this.tickObservations.map((entry) => entry.heapUsedBytes),
+            ...this.samples.flatMap((sample) => [
+                sample.processBeforeSnapshot.heapUsedBytes,
+                sample.processWithSnapshot.heapUsedBytes,
+                sample.processAfterRelease.heapUsedBytes,
+            ]),
+        ];
+        const observedRss = [
+            ...this.tickObservations.map((entry) => entry.rssBytes),
+            ...this.samples.flatMap((sample) => [
+                sample.processBeforeSnapshot.rssBytes,
+                sample.processWithSnapshot.rssBytes,
+                sample.processAfterRelease.rssBytes,
+            ]),
+        ];
+        const startIndex = input.startYear * 12 + input.startMonth - 1;
+        const unifiedIndex = input.unifiedAt.year * 12 + input.unifiedAt.month - 1;
+
+        return {
+            schemaVersion: 1,
+            runtime: {
+                node: process.version,
+                platform: process.platform,
+                arch: process.arch,
+                explicitGc: typeof globalThis.gc === 'function',
+            },
+            scenario: {
+                name: 'npcNationUprisingUnification-large-test-map',
+                initialGeneralCount: input.initialGeneralCount,
+                cityCount: this.samples[0]?.cityCount ?? 0,
+                startYear: input.startYear,
+                startMonth: input.startMonth,
+            },
+            result: {
+                unifiedAt: input.unifiedAt,
+                simulatedMonths: unifiedIndex - startIndex,
+                foundedNationCount: input.foundedNationCount,
+                declarationCount: input.declarationCount,
+                sortieCount: input.sortieCount,
+                wallDurationMs: performance.now() - input.startedAtMs,
+            },
+            memory: {
+                processIncludes: ['node', 'vitest-worker', 'scenario-harness', 'engine-state'],
+                maxObservedHeapUsedBytes: Math.max(0, ...observedHeap),
+                maxObservedRssBytes: Math.max(0, ...observedRss),
+                processResourceMaxRssBytes: process.resourceUsage().maxRSS * 1024,
+                participantSnapshotBytes: {
+                    initial: snapshotSizes[0] ?? 0,
+                    final: snapshotSizes.at(-1) ?? 0,
+                    peak: Math.max(0, ...snapshotSizes),
+                },
+                participantSnapshotHeapDeltaBytes: {
+                    peakWhileRetained: Math.max(0, ...retainedSnapshotHeapDeltas),
+                    peakAfterRelease: Math.max(0, ...releasedSnapshotHeapDeltas),
+                },
+                participantSnapshotCloneMs: {
+                    count: cloneTimes.length,
+                    average: average(cloneTimes),
+                    p95: percentile(cloneTimes, 0.95),
+                    max: Math.max(0, ...cloneTimes),
+                },
+            },
+            samples: this.samples,
+        };
+    }
+}