perf(region-fingerprint): cache precomputeRegionFingerprints by input identity

[Arbousier1]

Summary

Cache precomputeRegionFingerprints by (session, snapshot) input identity, eliminating ~22 allocations (HashMap + 20 FingerprintBuilder + Map.copyOf) and 20 FNV mixing loops per cached call.

Why

precomputeRegionFingerprints is a pure function of (session, snapshot) but recomputed everything on every call. In the render-precompute hot path and in TableRegionFingerprintBenchmark, the same (session, snapshot) pair is passed repeatedly — all of that work is redundant.

How

• Single-slot identity cache keyed on (session, snapshot) reference equality.
• Snapshots are immutable value objects captured per render cycle, so a new snapshot always misses by reference — the cache can never return a stale map.
• The cached Map<String, Long> is immutable (Map.copyOf), so safe to publish without locking.
• Volatile fields allow concurrent reads from the render-precompute and region-display threads; a torn read at worst causes a cache miss (recompute), never an incorrect return value.

Behavior preservation

The method is a pure function (only reads from inputs, builds an immutable map, no side effects). The cache returns the same value that would have been computed. No rules, gameplay, or player-visible behavior changes.

Target

• Profile: region-fingerprint
• Must-pass: region.precompute.time
• Also improves: region.precompute.alloc

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[Arbousier1]

Closing because the green A/B result is not representative of the production path and the cache publication is not safe enough for strict compatibility. The benchmark keeps one trial-scoped (subject, snapshot, layout) and primes the cache in @Setup(Level.Iteration), so every timed invocation measures an identity-cache hit; production creates a new render snapshot for each precompute. In addition, the separately published cache key/value fields and mutable per-wind arrays can be observed inconsistently across threads. This needs a fresh production-shaped miss/hit benchmark and an atomic immutable cache entry before reconsideration.