Per-node block allocation and partial work buffer updates for GSplats (#8490)

* Per-node block allocation and partial work buffer updates for GSplats

* updates

* updates

* updates

* update

---------

Co-authored-by: Martin Valigursky <mvaligursky@snapchat.com>

Author: mvaligursky

examples/src/examples/gaussian-splatting/lod-streaming.controls.mjs

@@ -89,7 +89,12 @@ export const controls = ({ observer, ReactPCUI, React, jsx, fragment }) => {
                         { v: '2M', t: '2M' },
                         { v: '3M', t: '3M' },
                         { v: '4M', t: '4M' },
-                        { v: '6M', t: '6M' }
+                        { v: '5M', t: '5M' },
+                        { v: '6M', t: '6M' },
+                        { v: '7M', t: '7M' },
+                        { v: '8M', t: '8M' },
+                        { v: '9M', t: '9M' },
+                        { v: '10M', t: '10M' }
                     ]
                 })
             )

examples/src/examples/gaussian-splatting/lod-streaming.example.mjs

@@ -81,7 +81,7 @@ const config = {
 const LOD_PRESETS = {
     'desktop-max': {
         range: [0, 5],
-        lodDistances: [10, 20, 40, 80, 120, 150, 200]
+        lodDistances: [7, 20, 40, 80, 120, 150, 200]
     },
     'desktop': {
         range: [1, 5],
@@ -119,21 +119,29 @@ assetListLoader.load(() => {
     app.scene.skyboxMip = 1;
     app.scene.exposure = 1.5;
 
-    // Mini-Stats: add gsplats on top of default stats
+    // Mini-Stats: insert gsplat stats after the default 'Frame' entry
     const msOptions = pc.MiniStats.getDefaultOptions();
-    msOptions.stats.push({
+    const frameIndex = msOptions.stats.findIndex(s => s.name === 'Frame');
+    msOptions.stats.splice(frameIndex + 1, 0, {
         name: 'GSplats',
         stats: ['frame.gsplats'],
         decimalPlaces: 3,
         multiplier: 1 / 1000000,
         unitsName: 'M',
         watermark: 10
+    }, {
+        name: 'GsplatsCopy',
+        stats: ['frame.gsplatBufferCopy'],
+        decimalPlaces: 1,
+        multiplier: 1,
+        unitsName: '%',
+        watermark: 100
     });
     const miniStats = new pc.MiniStats(app, msOptions); // eslint-disable-line no-unused-vars
 
     // enable rotation-based LOD updates and behind-camera penalty
     app.scene.gsplat.lodUpdateAngle = 90;
-    app.scene.gsplat.lodBehindPenalty = 5;
+    app.scene.gsplat.lodBehindPenalty = 3;
     app.scene.gsplat.radialSorting = true;
     app.scene.gsplat.lodUpdateDistance = config.lodUpdateDistance;
     app.scene.gsplat.lodUnderfillLimit = config.lodUnderfillLimit;
@@ -156,7 +164,7 @@ assetListLoader.load(() => {
 
     // initialize UI settings (must be after observer registration)
     data.set('gpuSorting', false);
-    data.set('culling', false);
+    data.set('culling', device.isWebGPU);
     data.set('compact', true);
     data.set('debugLod', false);
     data.set('lodPreset', pc.platform.mobile ? 'mobile' : 'desktop');
@@ -193,7 +201,12 @@ assetListLoader.load(() => {
             '2M': 2000000,
             '3M': 3000000,
             '4M': 4000000,
-            '6M': 6000000
+            '5M': 5000000,
+            '6M': 6000000,
+            '7M': 7000000,
+            '8M': 8000000,
+            '9M': 9000000,
+            '10M': 10000000
         };
         // Global splat budget applies to all GSplats in the scene
         app.scene.gsplat.splatBudget = budgetMap[preset] || 0;

examples/src/examples/gaussian-splatting/viewer.example.mjs

@@ -165,7 +165,7 @@ assetListLoader.load(() => {
     // Initialize data values
     data.set('data', {
         skydome: false,
-        compact: true,
+        compact: false,
         orientation: 180,
         tonemapping: pc.TONEMAP_LINEAR,
         grading: {

src/core/block-allocator.js

@@ -123,6 +123,17 @@ class BlockAllocator {
      */
     _tailFree = null;
 
+    /**
+     * Advisory starting point for the next free-block search. Avoids repeatedly scanning past
+     * small fragments at the start of the free list during sequential allocations. Cleared
+     * (set to null) on free() and defrag(), causing the next search to restart from _headFree
+     * since those operations may create earlier gaps.
+     *
+     * @type {MemBlock|null}
+     * @private
+     */
+    _freeHint = null;
+
     /**
      * Pool of recycled MemBlock objects.
      *
@@ -164,22 +175,23 @@ class BlockAllocator {
     _freeRegionCount = 0;
 
     /**
-     * Minimum growth increment used by {@link BlockAllocator#updateAllocation}.
+     * Multiplicative growth factor used by {@link BlockAllocator#updateAllocation}.
+     * When growing, the new capacity is at least `capacity * growMultiplier`.
      *
      * @type {number}
      * @private
      */
-    _growSize;
+    _growMultiplier;
 
     /**
      * Create a new BlockAllocator.
      *
      * @param {number} [capacity] - Initial address space capacity. Defaults to 0.
-     * @param {number} [growSize] - Minimum growth increment for auto-grow in
-     * {@link BlockAllocator#updateAllocation}. Defaults to 1024.
+     * @param {number} [growMultiplier] - Multiplicative growth factor for auto-grow in
+     * {@link BlockAllocator#updateAllocation}. Defaults to 1.1 (10% extra).
      */
-    constructor(capacity = 0, growSize = 1024) {
-        this._growSize = growSize;
+    constructor(capacity = 0, growMultiplier = 1.1) {
+        this._growMultiplier = growMultiplier;
         if (capacity > 0) {
             this._capacity = capacity;
             this._freeSize = capacity;
@@ -188,6 +200,7 @@ class BlockAllocator {
             this._tailAll = block;
             this._headFree = block;
             this._tailFree = block;
+            this._freeHint = block;
             this._freeRegionCount = 1;
         }
     }
@@ -339,6 +352,9 @@ class BlockAllocator {
      * @private
      */
     _removeFromFreeList(block) {
+        if (this._freeHint === block) {
+            this._freeHint = block._nextFree;
+        }
         if (block._prevFree) block._prevFree._nextFree = block._nextFree;
         else this._headFree = block._nextFree;
         if (block._nextFree) block._nextFree._prevFree = block._prevFree;
@@ -349,18 +365,36 @@ class BlockAllocator {
     }
 
     /**
-     * Scan the free list for the first block with size >= requested.
+     * Scan the free list for the first block with size >= requested, starting from _freeHint
+     * to skip past small fragments already examined by recent allocations.
      *
      * @param {number} size - Minimum size needed.
      * @returns {MemBlock|null} The first fitting free block, or null.
      * @private
      */
     _findFreeBlock(size) {
-        let block = this._headFree;
+        const hint = this._freeHint;
+        let block = hint ?? this._headFree;
         while (block) {
-            if (block._size >= size) return block;
+            if (block._size >= size) {
+                this._freeHint = block;
+                return block;
+            }
             block = block._nextFree;
         }
+
+        // Hint skipped earlier blocks — retry from head up to the hint
+        if (hint) {
+            block = this._headFree;
+            while (block !== hint) {
+                if (block._size >= size) {
+                    this._freeHint = block;
+                    return block;
+                }
+                block = block._nextFree;
+            }
+        }
+
         return null;
     }
 
@@ -406,6 +440,7 @@ class BlockAllocator {
         block._free = true;
         this._usedSize -= block._size;
         this._freeSize += block._size;
+        this._freeHint = null;
 
         const prev = block._prev;
         const next = block._next;
@@ -492,6 +527,7 @@ class BlockAllocator {
      */
     defrag(maxMoves = 0, result = new Set()) {
         result.clear();
+        this._freeHint = null;
 
         if (this._freeRegionCount === 0) return result;
 
@@ -724,10 +760,11 @@ class BlockAllocator {
                     totalRemaining += /** @type {number} */ (toAllocate[j]);
                 }
 
-                // Grow if needed
+                // Grow if needed, or if free space would be below headroom threshold
                 const neededCapacity = this._usedSize + totalRemaining;
-                if (neededCapacity > this._capacity) {
-                    this.grow(Math.max(this._capacity + this._growSize, neededCapacity));
+                const headroomCapacity = Math.ceil(neededCapacity * this._growMultiplier);
+                if (headroomCapacity > this._capacity) {
+                    this.grow(headroomCapacity);
                 }
 
                 // Full defrag: compact everything

src/framework/app-base.js

@@ -1134,6 +1134,7 @@ class AppBase extends EventHandler {
         this.graphicsDevice._drawCallsPerFrame = 0;
 
         stats.gsplats = this.renderer._gsplatCount;
+        stats.gsplatBufferCopy = this.renderer._gsplatBufferCopy ?? 0;
     }
 
     /** @private */

src/framework/stats.js

@@ -40,6 +40,7 @@ class ApplicationStats {
             triangles: 0,
             gsplats: 0,
             gsplatSort: 0,
+            gsplatBufferCopy: 0,
             otherPrimitives: 0,
             shaders: 0,
             materials: 0,

src/scene/gsplat-unified/gsplat-alloc-id.js

@@ -0,0 +1,13 @@
+import { NumericIds } from '../../core/numeric-ids.js';
+
+/**
+ * Centralized allocation ID generator for gsplat work buffer allocations.
+ * Provides unique IDs for placements and octree nodes that need persistent
+ * allocation tracking in the block allocator.
+ *
+ * @type {NumericIds}
+ * @ignore
+ */
+const GsplatAllocId = new NumericIds();
+
+export { GsplatAllocId };

src/scene/gsplat-unified/gsplat-director.js

@@ -260,6 +260,8 @@ class GSplatDirector {
         });
 
         let gsplatCount = 0;
+        let bufferCopyUploaded = 0;
+        let bufferCopyTotal = 0;
 
         // for all cameras in the composition
         const camerasComponents = comp.cameras;
@@ -311,16 +313,22 @@ class GSplatDirector {
                 for (const layerData of cameraData.layersMap.values()) {
                     if (layerData.gsplatManager) {
                         gsplatCount += layerData.gsplatManager.update();
+                        bufferCopyUploaded += layerData.gsplatManager.bufferCopyUploaded;
+                        bufferCopyTotal += layerData.gsplatManager.bufferCopyTotal;
                     }
                     if (layerData.gsplatManagerShadow) {
                         gsplatCount += layerData.gsplatManagerShadow.update();
+                        bufferCopyUploaded += layerData.gsplatManagerShadow.bufferCopyUploaded;
+                        bufferCopyTotal += layerData.gsplatManagerShadow.bufferCopyTotal;
                     }
                 }
             }
         }
 
         // update stats
         this.renderer._gsplatCount = gsplatCount;
+        this.renderer._gsplatBufferCopy = bufferCopyTotal > 0 ?
+            (bufferCopyUploaded / bufferCopyTotal * 100) : 0;
 
         // clear dirty flags
         this.scene.gsplat.frameEnd();