perf(chunk): cache and reuse sorted chunk offsets for planning

Author: Mapacheee

src/main/java/me/mapacheee/extendedhorizons/chunk/FakeChunkPlannerService.java

@@ -12,6 +12,8 @@
 
 public class FakeChunkPlannerService {
 
+  private final ConcurrentHashMap<Long, long[]> sortedOffsetsCache = new ConcurrentHashMap<>();
+
   public record PlanInput(
       int chunkX,
       int chunkZ,
@@ -39,20 +41,21 @@ public PlanResult build(PlanInput input) {
     int safeSquareRadius = (int) Math.floor(input.serverDistance() * input.safeSquareFactor());
     if (safeSquareRadius < 2) safeSquareRadius = 2;
 
-    Set<Long> neededChunks = new HashSet<>();
-    for (int dx = -effectiveRadius; dx <= effectiveRadius; dx++) {
-      for (int dz = -effectiveRadius; dz <= effectiveRadius; dz++) {
-        int cx = chunkX + dx;
-        int cz = chunkZ + dz;
-        int chebyshev = Math.max(Math.abs(dx), Math.abs(dz));
-        if (chebyshev <= safeSquareRadius) continue;
-        if (dx * dx + dz * dz > effectiveRadius * effectiveRadius) continue;
-        neededChunks.add(ChunkPos.asLong(cx, cz));
-      }
+    long[] sortedOffsets = getSortedOffsets(effectiveRadius, safeSquareRadius);
+    int offsetCount = sortedOffsets.length;
+    Set<Long> neededChunks = new HashSet<>(Math.max(16, offsetCount * 2));
+    for (long packedOffset : sortedOffsets) {
+      int dx = unpackX(packedOffset);
+      int dz = unpackZ(packedOffset);
+      neededChunks.add(ChunkPos.asLong(chunkX + dx, chunkZ + dz));
     }
 
+    Set<Long> sentChunks = input.sentChunksSnapshot();
+    Set<Long> queuedSet = input.queuedSet();
+    Set<Long> inflightSet = input.inflightSet();
+
     Set<Long> chunksToUnload = new HashSet<>();
-    for (Long chunkKey : input.sentChunksSnapshot()) {
+    for (Long chunkKey : sentChunks) {
       if (!neededChunks.contains(chunkKey)) {
         chunksToUnload.add(chunkKey);
       }
@@ -63,32 +66,25 @@ public PlanResult build(PlanInput input) {
     int kept = 0;
     for (Long existing : input.currentQueue()) {
       if (!neededChunks.contains(existing)) continue;
-      if (input.sentChunksSnapshot().contains(existing)) continue;
-      if (input.inflightSet().contains(existing)) continue;
+      if (sentChunks.contains(existing)) continue;
+      if (inflightSet.contains(existing)) continue;
       rebuiltQueue.addLast(existing);
       rebuiltQueuedSet.add(existing);
       kept++;
     }
 
-    List<Long> toAdd = new ArrayList<>();
-    for (Long chunkKey : neededChunks) {
-      if (input.sentChunksSnapshot().contains(chunkKey)) continue;
-      if (input.queuedSet().contains(chunkKey)) continue;
-      if (input.inflightSet().contains(chunkKey)) continue;
+    List<Long> toAdd = new ArrayList<>(offsetCount);
+    for (long packedOffset : sortedOffsets) {
+      int dx = unpackX(packedOffset);
+      int dz = unpackZ(packedOffset);
+      long chunkKey = ChunkPos.asLong(chunkX + dx, chunkZ + dz);
+      if (sentChunks.contains(chunkKey)) continue;
+      if (queuedSet.contains(chunkKey)) continue;
+      if (inflightSet.contains(chunkKey)) continue;
       if (rebuiltQueuedSet.contains(chunkKey)) continue;
       toAdd.add(chunkKey);
     }
 
-    toAdd.sort(
-        Comparator.comparingInt(
-            key -> {
-              int cx = ChunkPos.getX(key);
-              int cz = ChunkPos.getZ(key);
-              int dx = cx - chunkX;
-              int dz = cz - chunkZ;
-              return dx * dx + dz * dz;
-            }));
-
     return new PlanResult(
         safeSquareRadius,
         neededChunks,
@@ -98,4 +94,40 @@ public PlanResult build(PlanInput input) {
         toAdd,
         kept);
   }
+
+  private long[] getSortedOffsets(int effectiveRadius, int safeSquareRadius) {
+    long cacheKey = (((long) effectiveRadius) << 32) | (safeSquareRadius & 0xFFFFFFFFL);
+    return sortedOffsetsCache.computeIfAbsent(cacheKey, k -> buildSortedOffsets(effectiveRadius, safeSquareRadius));
+  }
+
+  private long[] buildSortedOffsets(int effectiveRadius, int safeSquareRadius) {
+    List<long[]> sortable = new ArrayList<>();
+    for (int dx = -effectiveRadius; dx <= effectiveRadius; dx++) {
+      for (int dz = -effectiveRadius; dz <= effectiveRadius; dz++) {
+        int chebyshev = Math.max(Math.abs(dx), Math.abs(dz));
+        if (chebyshev <= safeSquareRadius) continue;
+        int distSq = dx * dx + dz * dz;
+        if (distSq > effectiveRadius * effectiveRadius) continue;
+        sortable.add(new long[] {pack(dx, dz), distSq});
+      }
+    }
+    sortable.sort(Comparator.comparingLong(v -> v[1]));
+    long[] offsets = new long[sortable.size()];
+    for (int i = 0; i < sortable.size(); i++) {
+      offsets[i] = sortable.get(i)[0];
+    }
+    return offsets;
+  }
+
+  private static long pack(int x, int z) {
+    return (((long) x) << 32) | (z & 0xFFFFFFFFL);
+  }
+
+  private static int unpackX(long packed) {
+    return (int) (packed >> 32);
+  }
+
+  private static int unpackZ(long packed) {
+    return (int) packed;
+  }
 }

src/main/java/me/mapacheee/extendedhorizons/chunk/FakeChunkService.java

@@ -477,36 +477,40 @@ private void updatePlayerChunks(
 
     dispatchService.processQueue(
         player, world, playerId, tracker, getSessionEpoch(playerId), dispatchHooks);
-    String planDebug =
-        "[EH] plan moved="
-            + moved
-            + " force="
-            + force
-            + " pos="
-            + chunkX
-            + ","
-            + chunkZ
-            + " target="
-            + viewDistance
-            + " server="
-            + serverDistance
-            + " safe="
-            + plan.safeSquareRadius()
-            + " needed="
-            + plan.neededChunks().size()
-            + " sent="
-            + tracker.getSentChunks().size()
-            + " unload="
-            + plan.chunksToUnload().size()
-            + " kept="
-            + plan.kept()
-            + " add="
-            + plan.toAdd().size()
-            + " queue="
-            + queue.size()
-            + " inflight="
-            + inflightCounts.computeIfAbsent(playerId, k -> new AtomicInteger(0)).get();
-    debug(playerId, "plan", planDebug);
+    if (config().debugEnabled()) {
+      AtomicInteger inflight = inflightCounts.get(playerId);
+      int inflightCount = inflight == null ? 0 : inflight.get();
+      String planDebug =
+          "[EH] plan moved="
+              + moved
+              + " force="
+              + force
+              + " pos="
+              + chunkX
+              + ","
+              + chunkZ
+              + " target="
+              + viewDistance
+              + " server="
+              + serverDistance
+              + " safe="
+              + plan.safeSquareRadius()
+              + " needed="
+              + plan.neededChunks().size()
+              + " sent="
+              + tracker.getSentChunks().size()
+              + " unload="
+              + plan.chunksToUnload().size()
+              + " kept="
+              + plan.kept()
+              + " add="
+              + plan.toAdd().size()
+              + " queue="
+              + queue.size()
+              + " inflight="
+              + inflightCount;
+      debug(playerId, "plan", planDebug);
+    }
   }
 
   private void sendUnloadPacket(Player player, int x, int z) {