feat(pathfinding): non-eager TryGetMask + second-touch promotion (#2451)
## Summary Closes the Cold-cache regression flagged in PR #2450. `StepCache.TryGetMask` no longer eagerly runs `BuildChunk` on the first miss for a chunk that isn't in a `.swb` lazy reader. Instead it returns `Fallthrough_NotBuilt` and the caller (`BitmapAStarAlgorithm`) takes the per-cell slow path. The chunk is only promoted to the bitmap fast path after the **second** miss within a 30-second window, filtering single-touch pass-throughs. This makes BitmapAStar's worst-case (cold cache + short hops) collapse from **12–47× slower** than FastAStar to **roughly the same**, which is the floor the slow path can deliver. Steady-state warm performance (the actual deliverable) is unchanged from PR-5 — it was always the cache fast path. ## The pet-follow scenario this fixes A mounted player at ~4 tiles/sec with a pet/hireable following will trigger an NPC pathfind every 100–300 ms. Each pathfind is 1–6 tiles. As the player crosses chunk boundaries (~4 sec/chunk), the pet's first pathfind in the new chunk under the previous behavior triggered a full ~700 µs `BuildChunk` for a chunk the player would leave shortly after. At 50–100 mobiles per shard, this exceeded the 8 ms tick budget. PR-5 BDN data showed scenarios 6–9 (2–8 tile NPC perception) at 2,300–3,700 µs Cold vs FastAStar's 80–200 µs. Under the new gate: - First miss → `Fallthrough_NotBuilt` → caller uses slow path (~30–50 µs short path). No `BuildChunk`. No allocation. - Player keeps moving → chunk never gets a second touch within window → never promoted, no rot. - NPC patrolling a fixed territory → repeatedly hits the same chunks → second touch within window → promote → cache fast path on subsequent calls. ## What changed - **`CacheHitKind.Fallthrough_NotBuilt = 6`** + **`CacheStats.FallthroughNotBuilt`** counter. `IsHit=false`, so the caller routes to slow path. - **`StepCache._chunkMissTracker`** — `Dictionary<long, ChunkMissState>` capped at 4096 entries. State is `(byte missCount, uint lastMissTickStamp)` keyed by chunk key. Window-expired entries reset count to 1; capacity overflow prunes window-old entries first. - **`StepCache.MissPromotionThreshold`** (default `2`) and **`StepCache.MissPromotionWindowMs`** (default `30_000`) — tunable, can be wired through `ServerConfiguration` if shards want different policy. Setting threshold to `1` restores legacy eager-build behavior (used by tests that prime chunks via single `TryGetMask` call). - **`StepCache.TryGetMask` miss branch** — try lazy reader first (file-loaded chunks bypass the tracker entirely; an `.swb` represents an explicit prior decision to keep the chunk warm). Otherwise consult the tracker. - **`BitmapAStarAlgorithm.GetSuccessorsSlowPath`** now layers `IsBlockedByDynamic` on top of `CalcMoves.CheckMovement`. Previously the slow path only ran for `CanFly` creatures and rare cache fallthroughs — `CheckMovement` doesn't iterate same-cell mobiles, so the bitmap fast path's `IsBlockedByDynamic` was the only mobile-blocking check. Now first-touch pathfinds run through the slow path, so the gap had to close. ## Tests 50 pathfinding tests pass (was 47). New / updated: - **`TryGetMask_FirstTouchOnUnbuiltChunk_DefersBuildAndReturnsFallthrough`** — single TryGetMask call returns `Fallthrough_NotBuilt`, no chunk built, no allocation. - **`TryGetMask_SecondTouchWithinWindow_PromotesAndBuilds`** — second call inside the 30s window builds + serves. - **`TryGetMask_SecondTouchAfterWindow_RestartsCounterAndDefers`** — second call outside the window restarts the count, returns Fallthrough again. - **`TryGetMask_DistinctChunks_TrackedIndependently`** — counters are per-chunk; one touch on each of two adjacent chunks both stay in fallthrough. - **`LazyReaderHit_BypassesMissTrackerOnFirstTouch`** — open `.swb` + first touch hits without consulting the tracker. Production with `.swb` loaded skips the gate entirely. - **`MultisVersion_Bump_TriggersDirtyRebuild`** — updated to reflect the new 3-step flow (Fallthrough → Miss_NotBuilt → Miss_DirtyRebuild). - Tests that prime chunks via a single `TryGetMask` call (multi-Z, Tier4, lifecycle, parity, BitmapAStar uses-cache) set `MissPromotionThreshold = 1` to opt into eager behavior. ## Expected BDN impact The Cold column from PR-5's BDN should change as follows once the bench's submodule pointer is updated to this branch: | # | Scenario | Cold (PR-5) | Cold (PR-6 expected) | FastAStar Cold | |--:|-----------------|-------------:|---------------------:|---------------:| | 2 | sewer corridor | 1,627 µs | ~36 µs | 36 µs | | 4 | causeway | 1,533 µs | ~39 µs | 39 µs | | 6 | pet 2-tile | 2,364 µs | ~80 µs | 81 µs | | 8 | npc 5-tile | 3,708 µs | ~140 µs | 141 µs | | 9 | npc 8-tile | 2,386 µs | ~200 µs | 197 µs | WarmNoFile and LazyWarm rows should be unchanged — they were always cache-warm. The miss tracker only fires when neither resident chunks nor the lazy reader can satisfy the request. ## Future work (not in this PR) - **Background-thread bake**: builds outside the game thread so even promoted chunks don't pay the 700 µs build cost on the main thread. Rule 10 (no Task.Run) applies, so this needs careful design — the bake is a pure data transform but main-thread synchronization on chunk-state transitions has to be threaded through. Defer to a follow-up. - **Long-traverse BDN scenario**: a multi-Find benchmark simulating 50 pet repaths across chunk transitions. Requires restructuring the bench harness; the existing 10-scenario corpus + Cold provider already exercises the gate. - **Swim sourceZ bake**: scenario 5 (sea serpent) shows 56 B alloc on warm paths because the cache's SourceZ is computed under default-walker rules. Swim creatures fall through to slow path. Independent of this PR.
This commit is contained in:
Kamron Batman
GitHub
parent
cff9fbda29
commit
9a3d88988c
14 changed files with 1664 additions and 163 deletions
|
|
@ -37,6 +37,91 @@ internal sealed class StepChunk
|
|||
public readonly sbyte[] SwimZW = new sbyte[CellsPerChunk];
|
||||
public readonly sbyte[] SwimZNW = new sbyte[CellsPerChunk];
|
||||
|
||||
/// <summary>
|
||||
/// Swim layer — populated only for chunks containing at least one shore cell (a cell
|
||||
/// with both a walkable land surface and a water surface separated by > StepHeight).
|
||||
/// On shore cells, queries from the swim source Z miss the primary source-Z guard;
|
||||
/// the swim layer carries the correct wetMask + per-direction destination Zs computed
|
||||
/// from the water surface's perspective. For non-shore cells in a chunk that has the
|
||||
/// layer, <see cref="SwimSourceZ"/>[cell] = <see cref="NoSwimLayerCell"/> sentinel.
|
||||
/// All swim-layer arrays are null on chunks with no shore cells (~90% of map chunks
|
||||
/// on Trammel) — zero memory cost on the common case.
|
||||
/// </summary>
|
||||
public const sbyte NoSwimLayerCell = sbyte.MinValue;
|
||||
|
||||
private sbyte[] _swimSourceZ;
|
||||
private byte[] _swimMask;
|
||||
private sbyte[] _swimZN_extra;
|
||||
private sbyte[] _swimZNE_extra;
|
||||
private sbyte[] _swimZE_extra;
|
||||
private sbyte[] _swimZSE_extra;
|
||||
private sbyte[] _swimZS_extra;
|
||||
private sbyte[] _swimZSW_extra;
|
||||
private sbyte[] _swimZW_extra;
|
||||
private sbyte[] _swimZNW_extra;
|
||||
|
||||
/// <summary>True when this chunk has at least one shore cell with a populated swim layer.</summary>
|
||||
public bool HasSwimLayer => _swimSourceZ != null;
|
||||
|
||||
/// <summary>Per-cell water-surface standing Z (or <see cref="NoSwimLayerCell"/>). Null when chunk has no swim layer.</summary>
|
||||
public sbyte[] SwimSourceZ => _swimSourceZ;
|
||||
/// <summary>Per-cell swim mask computed at <see cref="SwimSourceZ"/>. Null when chunk has no swim layer.</summary>
|
||||
public byte[] SwimMask => _swimMask;
|
||||
public sbyte[] SwimZN_Layer => _swimZN_extra;
|
||||
public sbyte[] SwimZNE_Layer => _swimZNE_extra;
|
||||
public sbyte[] SwimZE_Layer => _swimZE_extra;
|
||||
public sbyte[] SwimZSE_Layer => _swimZSE_extra;
|
||||
public sbyte[] SwimZS_Layer => _swimZS_extra;
|
||||
public sbyte[] SwimZSW_Layer => _swimZSW_extra;
|
||||
public sbyte[] SwimZW_Layer => _swimZW_extra;
|
||||
public sbyte[] SwimZNW_Layer => _swimZNW_extra;
|
||||
|
||||
/// <summary>
|
||||
/// Lazily allocates the swim-layer arrays and seeds <see cref="SwimSourceZ"/> with
|
||||
/// the <see cref="NoSwimLayerCell"/> sentinel. Called at bake time the first time a
|
||||
/// shore cell is detected in this chunk.
|
||||
/// </summary>
|
||||
internal void AllocateSwimLayer()
|
||||
{
|
||||
if (_swimSourceZ != null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_swimSourceZ = new sbyte[CellsPerChunk];
|
||||
_swimMask = new byte[CellsPerChunk];
|
||||
_swimZN_extra = new sbyte[CellsPerChunk];
|
||||
_swimZNE_extra = new sbyte[CellsPerChunk];
|
||||
_swimZE_extra = new sbyte[CellsPerChunk];
|
||||
_swimZSE_extra = new sbyte[CellsPerChunk];
|
||||
_swimZS_extra = new sbyte[CellsPerChunk];
|
||||
_swimZSW_extra = new sbyte[CellsPerChunk];
|
||||
_swimZW_extra = new sbyte[CellsPerChunk];
|
||||
_swimZNW_extra = new sbyte[CellsPerChunk];
|
||||
for (var i = 0; i < CellsPerChunk; i++)
|
||||
{
|
||||
_swimSourceZ[i] = NoSwimLayerCell;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Test/serialization hook: install pre-built swim-layer arrays. Pass nulls to clear.</summary>
|
||||
internal void SetSwimLayer(
|
||||
sbyte[] swimSourceZ, byte[] swimMask,
|
||||
sbyte[] zN, sbyte[] zNE, sbyte[] zE, sbyte[] zSE,
|
||||
sbyte[] zS, sbyte[] zSW, sbyte[] zW, sbyte[] zNW
|
||||
)
|
||||
{
|
||||
_swimSourceZ = swimSourceZ;
|
||||
_swimMask = swimMask;
|
||||
_swimZN_extra = zN;
|
||||
_swimZNE_extra = zNE;
|
||||
_swimZE_extra = zE;
|
||||
_swimZSE_extra = zSE;
|
||||
_swimZS_extra = zS;
|
||||
_swimZSW_extra = zSW;
|
||||
_swimZW_extra = zW;
|
||||
_swimZNW_extra = zNW;
|
||||
}
|
||||
|
||||
/// <summary>Sentinel: cell has no strata — single-Z, use the main Walk/Wet arrays.</summary>
|
||||
public const ushort NoStrata = ushort.MaxValue;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue