Add adaptive traversal and upload-pressure backpressure controls

Author: j-shelfwood

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/AsyncNodeManager.java

@@ -71,6 +71,10 @@ public class AsyncNodeManager {
     private final GeometryCache geometryCache = new GeometryCache(1L<<32);
 
     private final AtomicInteger workCounter = new AtomicInteger();
+    private static final boolean ENABLE_UPLOAD_BACKPRESSURE_DEFERRAL =
+            System.getProperty("voxy.asyncNodeUploadBackpressureDeferral", "true").equalsIgnoreCase("true");
+    private static final int UPLOAD_BACKPRESSURE_LOG_COOLDOWN_FRAMES =
+            Math.max(1, Integer.getInteger("voxy.asyncNodeUploadBackpressureLogCooldownFrames", 120));
 
     @SuppressWarnings("FieldMayBeFinal")
     private volatile SyncResults results = null, resultCache1 = new SyncResults(), resultCache2 = new SyncResults();
@@ -82,6 +86,7 @@ public class AsyncNodeManager {
     private final IntOpenHashSet cleanerIdResetClear = new IntOpenHashSet();//Tells the cleaner if it needs to clear the id to 0, or reset the id to the current frame
 
     private boolean needsWaitForSync = false;
+    private int uploadBackpressureLogCooldown;
 
     public AsyncNodeManager(int maxNodeCount, IGeometryData geometryData, RenderGenerationService renderService) {
         //Note the current implmentation of ISectionWatcher is threadsafe
@@ -496,6 +501,20 @@ public void tick(GlBuffer nodeBuffer, NodeCleaner cleaner) {//TODO: dont pass no
             return;
         }
 
+        if (ENABLE_UPLOAD_BACKPRESSURE_DEFERRAL) {
+            long estimatedUploadBytes = this.estimateRenderThreadUploadBytes(results);
+            if (UploadStream.INSTANCE.shouldDefer(estimatedUploadBytes)) {
+                if (this.uploadBackpressureLogCooldown-- <= 0) {
+                    this.uploadBackpressureLogCooldown = UPLOAD_BACKPRESSURE_LOG_COOLDOWN_FRAMES;
+                    Logger.info("[AsyncNodeManager] Deferring sync due to upload pressure; estBytes=" + estimatedUploadBytes);
+                }
+                if (!RESULT_HANDLE.compareAndSet(this, null, results)) {
+                    throw new IllegalStateException("Failed to requeue sync results under upload pressure");
+                }
+                return;
+            }
+        }
+
         //top level node add/remove
         if (!results.tlnDelta.isEmpty()) {
             var iter = results.tlnDelta.intIterator();
@@ -583,6 +602,24 @@ public void tick(GlBuffer nodeBuffer, NodeCleaner cleaner) {//TODO: dont pass no
         }
     }
 
+    private long estimateRenderThreadUploadBytes(SyncResults results) {
+        long bytes = 0L;
+        if (!results.geometryUpload.dataUploadPoints.isEmpty()) {
+            int copies = results.geometryUpload.dataUploadPoints.size();
+            int scratchSize = (int) results.geometryUpload.arena.getSize() * 8;
+            bytes += (long) scratchSize + (long) copies * 16L;
+        }
+        if (!results.scatterWriteLocationMap.isEmpty()) {
+            int count = results.scatterWriteLocationMap.size();
+            int chunks = (count + 3) / 4;
+            bytes += (long) chunks * 80L + 16L;
+        }
+        if (!results.cleanerOperations.isEmpty()) {
+            bytes += (long) results.cleanerOperations.size() * 4L + 16L;
+        }
+        return bytes;
+    }
+
 
     public void setTLNAddRemoveCallbacks(IntConsumer add, IntConsumer remove) {
         this.tlnAddCallback = add;

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/HierarchicalOcclusionTraverser.java

@@ -89,6 +89,20 @@ public class HierarchicalOcclusionTraverser {
             Float.parseFloat(System.getProperty("voxy.requestFrustumDirectionalMaxExtra", "64.0"));
     private static final int TRAVERSAL_INTERVAL_FRAMES =
             Math.max(1, Integer.parseInt(System.getProperty("voxy.traversalIntervalFrames", "1")));
+    private static final boolean ENABLE_ADAPTIVE_TRAVERSAL_INTERVAL =
+            System.getProperty("voxy.adaptiveTraversalInterval", "true").equalsIgnoreCase("true");
+    private static final int TRAVERSAL_MAX_INTERVAL_FRAMES =
+            Math.max(TRAVERSAL_INTERVAL_FRAMES, Integer.parseInt(System.getProperty("voxy.traversalIntervalMaxFrames", "3")));
+    private static final double TRAVERSAL_FORCE_MOTION_BLOCKS =
+            Double.parseDouble(System.getProperty("voxy.traversalForceMotionBlocks", "1.25"));
+    private static final double TRAVERSAL_FORCE_ROTATION_DEGREES =
+            Double.parseDouble(System.getProperty("voxy.traversalForceRotationDegrees", "1.0"));
+    private static final int TRAVERSAL_FORCE_BACKLOG_HIGH =
+            Math.max(1, Integer.parseInt(System.getProperty("voxy.traversalForceBacklogHigh", "1500")));
+    private static final int TRAVERSAL_BACKLOG_LOW =
+            Math.max(0, Integer.parseInt(System.getProperty("voxy.traversalBacklogLow", "300")));
+    private static final int HIZ_DISABLE_FROM_LOD =
+            Math.max(0, Integer.parseInt(System.getProperty("voxy.hizDisableFromLod", String.valueOf(MAX_ITERATIONS + 1))));
     private double lastCamX = Double.NaN, lastCamY = Double.NaN, lastCamZ = Double.NaN;
     private float lastNearPlaneX = Float.NaN, lastNearPlaneY = Float.NaN, lastNearPlaneZ = Float.NaN;
     private double lastRequestBudget = Double.NaN;
@@ -115,6 +129,7 @@ public class HierarchicalOcclusionTraverser {
             .define("MAX_ITERATIONS", MAX_ITERATIONS)
             .define("LOCAL_SIZE_BITS", LOCAL_WORK_SIZE_BITS)
             .define("MAX_REQUEST_QUEUE_SIZE", MAX_REQUEST_QUEUE_SIZE)
+            .define("HIZ_DISABLE_FROM_LOD", HIZ_DISABLE_FROM_LOD)
 
             .define("HIZ_BINDING", 0)
 
@@ -362,8 +377,9 @@ private void bindings(Viewport<?> viewport) {
     }
 
     public void doTraversal(Viewport<?> viewport) {
+        int traversalInterval = this.computeTraversalInterval(viewport);
         this.traversalFrameCounter++;
-        if (TRAVERSAL_INTERVAL_FRAMES > 1 && (this.traversalFrameCounter % TRAVERSAL_INTERVAL_FRAMES) != 0) {
+        if (traversalInterval > 1 && (this.traversalFrameCounter % traversalInterval) != 0) {
             return;
         }
         this.uploadUniform(viewport);
@@ -402,6 +418,48 @@ public void doTraversal(Viewport<?> viewport) {
         glBindTextureUnit(0, 0);
     }
 
+    private int computeTraversalInterval(Viewport<?> viewport) {
+        if (!ENABLE_ADAPTIVE_TRAVERSAL_INTERVAL) {
+            return TRAVERSAL_INTERVAL_FRAMES;
+        }
+        int backlog = this.meshGen.getTaskCount();
+        if (backlog >= TRAVERSAL_FORCE_BACKLOG_HIGH) {
+            return 1;
+        }
+        if (!Double.isNaN(this.lastCamX)) {
+            double dx = viewport.cameraX - this.lastCamX;
+            double dy = viewport.cameraY - this.lastCamY;
+            double dz = viewport.cameraZ - this.lastCamZ;
+            double motion = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            if (motion >= TRAVERSAL_FORCE_MOTION_BLOCKS) {
+                return 1;
+            }
+            if (!Float.isNaN(this.lastNearPlaneX)) {
+                float nearPlaneX = viewport.frustumPlanes[4].x;
+                float nearPlaneY = viewport.frustumPlanes[4].y;
+                float nearPlaneZ = viewport.frustumPlanes[4].z;
+                double dot = nearPlaneX * this.lastNearPlaneX
+                        + nearPlaneY * this.lastNearPlaneY
+                        + nearPlaneZ * this.lastNearPlaneZ;
+                dot = Math.max(-1.0, Math.min(1.0, dot));
+                double rotationDegrees = Math.toDegrees(Math.acos(dot));
+                if (rotationDegrees >= TRAVERSAL_FORCE_ROTATION_DEGREES) {
+                    return 1;
+                }
+            }
+        }
+
+        if (backlog <= TRAVERSAL_BACKLOG_LOW) {
+            return TRAVERSAL_MAX_INTERVAL_FRAMES;
+        }
+        int span = Math.max(1, TRAVERSAL_FORCE_BACKLOG_HIGH - TRAVERSAL_BACKLOG_LOW);
+        double normalized = 1.0 - ((double) (backlog - TRAVERSAL_BACKLOG_LOW) / span);
+        normalized = Math.max(0.0, Math.min(1.0, normalized));
+        int adaptive = TRAVERSAL_INTERVAL_FRAMES
+                + (int) Math.round(normalized * (TRAVERSAL_MAX_INTERVAL_FRAMES - TRAVERSAL_INTERVAL_FRAMES));
+        return Math.max(1, Math.min(TRAVERSAL_MAX_INTERVAL_FRAMES, adaptive));
+    }
+
     private void traverseInternal() {
         {
             //Fix mesa bug

src/main/java/me/cortex/voxy/client/core/rendering/hierachical/NodeCleaner.java

@@ -79,6 +79,8 @@ public class NodeCleaner {
             Integer.parseInt(System.getProperty("voxy.nodeCleanerInterval", "1"));
     private static final long CLEAN_REMAINING_GEOMETRY_THRESHOLD_BYTES =
             Long.parseLong(System.getProperty("voxy.nodeCleanerMinRemainingBytes", "100000000"));
+    private static final boolean DEFER_ON_UPLOAD_PRESSURE =
+            System.getProperty("voxy.nodeCleanerDeferOnUploadPressure", "true").equalsIgnoreCase("true");
 
     private int frameCounter = 0;
     private int deferCleanFrames = 0;
@@ -220,6 +222,9 @@ private boolean shouldCleanGeometry() {
     public void updateIds(IntOpenHashSet collection) {
         if (!collection.isEmpty()) {
             int count = collection.size();
+            if (DEFER_ON_UPLOAD_PRESSURE && UploadStream.INSTANCE.shouldDefer(count * 4L + 16L)) {
+                return;
+            }
             long addr = UploadStream.INSTANCE.rawUploadAddress(count * 4 + 16);//TODO ensure alignment, create method todo alignment things
             addr = (addr+15)&~15L;//Align to 16 bytes
 

src/main/java/me/cortex/voxy/client/core/rendering/util/UploadStream.java

@@ -32,6 +32,10 @@ public class UploadStream {
     private static final boolean USE_COHERENT = false;
     private static final int STREAM_FULL_ATTEMPTS =
             Math.max(1, Integer.getInteger("voxy.uploadStreamFullAttempts", 4));
+    private static final boolean ALLOW_FORCED_FINISH =
+            System.getProperty("voxy.uploadStreamAllowFinish", "false").equalsIgnoreCase("true");
+    private static final double DEFER_USAGE_THRESHOLD =
+            Math.max(0.0, Math.min(1.0, Double.parseDouble(System.getProperty("voxy.uploadStreamDeferUsageThreshold", "0.90"))));
     private static final boolean LOG_UPLOAD_PRESSURE =
             System.getProperty("voxy.logUploadPressure", "true").equalsIgnoreCase("true");
     private static final int LOG_UPLOAD_PRESSURE_EVERY =
@@ -99,12 +103,14 @@ public long rawUploadAddress(int size) {
                     this.maybeLogUploadPressure();
                 }
 
-                int attempts = STREAM_FULL_ATTEMPTS;
-                while (--attempts != 0 && this.caddr == SIZE_LIMIT) {
-                    this.streamFullForcedFinishCalls++;
-                    glFinish();
-                    this.tick(false);
-                    this.caddr = this.allocationArena.alloc((int) size);
+                if (ALLOW_FORCED_FINISH) {
+                    int attempts = STREAM_FULL_ATTEMPTS;
+                    while (--attempts != 0 && this.caddr == SIZE_LIMIT) {
+                        this.streamFullForcedFinishCalls++;
+                        glFinish();
+                        this.tick(false);
+                        this.caddr = this.allocationArena.alloc((int) size);
+                    }
                 }
                 if (this.caddr == SIZE_LIMIT) {
                     this.streamFullHardFailures++;
@@ -185,6 +191,19 @@ public int getRawBufferId() {
         return this.uploadBuffer.id;
     }
 
+    public boolean shouldDefer(long incomingBytes) {
+        if (incomingBytes <= 0) {
+            return false;
+        }
+        long limit = this.allocationArena.getLimit();
+        if (limit <= 0) {
+            return false;
+        }
+        long used = this.allocationArena.getSize();
+        long free = Math.max(0L, limit - used);
+        return free < incomingBytes || ((double) used / (double) limit) >= DEFER_USAGE_THRESHOLD;
+    }
+
     private void maybeLogUploadPressure() {
         if (!LOG_UPLOAD_PRESSURE) {
             return;

src/main/resources/assets/voxy/shaders/lod/hierarchical/traversal_dev.comp

@@ -128,7 +128,8 @@ void traverse(in UnpackedNode node) {
     #ifdef DISABLE_TRAVERSAL_VISIBILITY_CULLING
     if (false) {
     #else
-    if (outsideFrustum() || isCulledByHiz()) {
+    bool hizCulled = node.lodLevel < HIZ_DISABLE_FROM_LOD && isCulledByHiz();
+    if (outsideFrustum() || hizCulled) {
     #endif
         //printf("culled");
     } else {