Merge branch 'ref-count-buffers' into 'main'

[REMIX-5807] Refactor the buffer cache update to not require per-frame work.

See merge request lightspeedrtx/dxvk-remix-nv!2251

Author: MarkEHenderson

src/dxvk/dxvk_stats.h

@@ -30,7 +30,9 @@ namespace dxvk {
     // NV-DXVK begin: RTX Remix counters
     CmdTraceRaysCalls,                 ///< Number of traceRays calls
     RtxBlasCount,                      ///< Number of unique BLAS's in the scene/geometry cache
-    RtxBufferCount,                    ///< Number of unique buffers being tracked for RT rendering
+    RtxBufferCount,                    ///< Number of unique (buffer, offset, length) slices tracked for RT rendering.
+                                       ///< Interleaved attributes share one slot; slots are retained until the
+                                       ///< owning BlasEntry is GC'd, so this is not a per-frame peak.
     RtxTextureCount,                   ///< Number of unique textures being tracked for RT rendering
     RtxReplacementTextureCount,        ///< Number of replacement textures currently used by at least one live instance
     RtxInstanceCount,                  ///< Number of surfaces and TLAS instance nodes in the scene

src/dxvk/rtx_render/rtx_instance_manager.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2021-2023, NVIDIA CORPORATION. All rights reserved.
+* Copyright (c) 2021-2026, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -164,6 +164,30 @@ namespace dxvk {
 
   void RtInstance::setBlas(BlasEntry& blas) {
     m_linkedBlas = &blas;
+    syncBufferIndicesFromBlas();
+  }
+
+  void RtInstance::syncBufferIndicesFromBlas() {
+    if (m_linkedBlas == nullptr) {
+      return;
+    }
+    const RaytraceGeometry& geo = m_linkedBlas->modifiedGeometryData;
+    surface.positionBufferIndex = geo.positionBufferIndex;
+    surface.positionOffset      = geo.positionBuffer.offsetFromSlice();
+    surface.positionStride      = geo.positionBuffer.stride();
+    surface.normalBufferIndex   = geo.normalBufferIndex;
+    surface.normalOffset        = geo.normalBuffer.offsetFromSlice();
+    surface.normalStride        = geo.normalBuffer.stride();
+    surface.normalFormat        = geo.normalBuffer.vertexFormat();
+    surface.color0BufferIndex   = geo.color0BufferIndex;
+    surface.color0Offset        = geo.color0Buffer.offsetFromSlice();
+    surface.color0Stride        = geo.color0Buffer.stride();
+    surface.texcoordBufferIndex = geo.texcoordBufferIndex;
+    surface.texcoordOffset      = geo.texcoordBuffer.offsetFromSlice();
+    surface.texcoordStride      = geo.texcoordBuffer.stride();
+    surface.previousPositionBufferIndex = geo.previousPositionBufferIndex;
+    surface.indexBufferIndex    = geo.indexBufferIndex;
+    surface.indexStride         = geo.indexBuffer.stride();
   }
 
   void RtInstance::copyInstanceDataFrom(const RtInstance& src) {
@@ -228,10 +252,14 @@ namespace dxvk {
       m_vkInstance.transform = savedVkTransform;
     }
 
+    // Clones are not linked into BlasEntry::m_linkedInstances (see createInstanceCopy), so
+    // updateBufferCache's push never reaches them. Re-derive from the BLAS rather than relying on
+    // the reference instance having been refreshed first.
+    syncBufferIndicesFromBlas();
+
     // Mark dirty so the incremental BLAS cache treats this instance as changed.
     m_blasDirty = true;
     m_billboardGeometryDirty = true;
-
   }
 
   void RtInstance::onTransformChanged() {
@@ -922,26 +950,13 @@ namespace dxvk {
     m_instances.push_back(newInstance);
     notifySceneChanged();
 
-    return newInstance;
-  }
+    // Renderer-created clones (view model, player model, ray-portal virtual instances) deliberately
+    // skip onInstanceAdded, so BlasEntry::linkInstance is never called for them and
+    // updateBufferCache's propagation will not reach them. Derive the indices straight from the BLAS
+    // instead of trusting the indices copied from the reference instance.
+    newInstance->syncBufferIndicesFromBlas();
 
-  void InstanceManager::processInstanceBuffers(const BlasEntry& blas, RtInstance& currentInstance) const {
-    currentInstance.surface.positionBufferIndex = blas.modifiedGeometryData.positionBufferIndex;
-    currentInstance.surface.positionOffset = blas.modifiedGeometryData.positionBuffer.offsetFromSlice();
-    currentInstance.surface.positionStride = blas.modifiedGeometryData.positionBuffer.stride();
-    currentInstance.surface.normalBufferIndex = blas.modifiedGeometryData.normalBufferIndex;
-    currentInstance.surface.normalOffset = blas.modifiedGeometryData.normalBuffer.offsetFromSlice();
-    currentInstance.surface.normalStride = blas.modifiedGeometryData.normalBuffer.stride();
-    currentInstance.surface.normalFormat = blas.modifiedGeometryData.normalBuffer.vertexFormat();
-    currentInstance.surface.color0BufferIndex = blas.modifiedGeometryData.color0BufferIndex;
-    currentInstance.surface.color0Offset = blas.modifiedGeometryData.color0Buffer.offsetFromSlice();
-    currentInstance.surface.color0Stride = blas.modifiedGeometryData.color0Buffer.stride();
-    currentInstance.surface.texcoordBufferIndex = blas.modifiedGeometryData.texcoordBufferIndex;
-    currentInstance.surface.texcoordOffset = blas.modifiedGeometryData.texcoordBuffer.offsetFromSlice();
-    currentInstance.surface.texcoordStride = blas.modifiedGeometryData.texcoordBuffer.stride();
-    currentInstance.surface.previousPositionBufferIndex = blas.modifiedGeometryData.previousPositionBufferIndex;
-    currentInstance.surface.indexBufferIndex = blas.modifiedGeometryData.indexBufferIndex;
-    currentInstance.surface.indexStride = blas.modifiedGeometryData.indexBuffer.stride();
+    return newInstance;
   }
 
   // Returns true if the instance was modified
@@ -1048,8 +1063,6 @@ namespace dxvk {
     if (isFirstUpdateThisFrame || overridePreviousCameraUpdate) {
 
       if (isFirstUpdateThisFrame) {
-        processInstanceBuffers(blas, currentInstance);
-
         currentInstance.m_materialType = materialData->getType();
 
         const XXH64_hash_t materialInstanceHash = materialData->getHash();
@@ -1139,7 +1152,14 @@ namespace dxvk {
                                    || currentInstance.testCategoryFlags(InstanceCategories::Particle)
                                    || currentInstance.testCategoryFlags(InstanceCategories::WorldUI);
 
-        hasPreviousPositions = blas.modifiedGeometryData.previousPositionBuffer.defined() && !isMotionUnstable;
+        // previousPositionBuffer is only re-pointed at historyBuffer[1] by processGeometryInfo on a
+        // kUpdateBVH frame. On any later frame it still holds that older slice - e.g. a preserved
+        // BLAS, or the kUpdateInstance early-out in onSceneObjectUpdated when a sibling draw already
+        // touched this BlasEntry. Gate on frameLastUpdated so stale vertices never feed motion vectors.
+        const bool previousPositionsValidThisFrame = blas.frameLastUpdated == m_device->getCurrentFrameId();
+        hasPreviousPositions = previousPositionsValidThisFrame
+                            && blas.modifiedGeometryData.previousPositionBuffer.defined()
+                            && !isMotionUnstable;
         const bool isFirstUpdateAfterCreation = currentInstance.isCreatedThisFrame(m_device->getCurrentFrameId()) && isFirstUpdateThisFrame;
 
         // Note: objectToView is aliased on updates, since findSimilarInstance() doesn't discern it

src/dxvk/rtx_render/rtx_instance_manager.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2021-2023, NVIDIA CORPORATION. All rights reserved.
+* Copyright (c) 2021-2026, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -100,9 +100,14 @@ class RtInstance {
   // Leave it false before relative transforms, such as portal teleports.
   void updateFromReference(const RtInstance& src, bool preserveTransforms = true);
 
-  // Bind a BLAS object to this instance
+  // Bind a BLAS object to this instance and sync buffer indices/strides from its geometry data.
   void setBlas(BlasEntry& blas);
 
+  // Syncs surface buffer indices and strides from the currently bound BLAS.
+  // Called by setBlas() on initial bind or re-link, and by updateBufferCache()
+  // when geometry buffer slots change mid-scene.
+  void syncBufferIndicesFromBlas();
+
   // Sets current and previous transforms explicitly
   bool teleport(const Matrix4& objectToWorld);
   bool teleport(const Matrix4& objectToWorld, const Matrix4& prevObjectToWorld);
@@ -357,9 +362,6 @@ class InstanceManager : public CommonDeviceObject {
   // Binds a raytracing material to the specified instance.
   void bindMaterial(RtInstance& instance, const RtSurfaceMaterial& material);
 
-  // Copies buffer indices from the BlasEntry's geometry data to the instance's surface.
-  void processInstanceBuffers(const BlasEntry& blas, RtInstance& currentInstance) const;
-
   // Per-frame finalization shared by the dynamic and preserve paths:
   // re-registers the player-model / view-model candidate lists (cleared every onFrameEnd) and
   // dispatches onInstanceUpdated to listeners.

src/dxvk/rtx_render/rtx_retained_buffer_table.h

@@ -0,0 +1,125 @@
+/*
+* Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+#pragma once
+
+#include <cassert>
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
+
+#include "../util/util_struct_hash.h"
+
+// Retained buffer registration table. Each distinct (buffer ptr, offset, length) triple
+// gets a stable slot index that persists across frames. acquire() is ref-counted; the slot
+// is returned to a free-list when the last release() fires. Slots left in the table by
+// free-listed entries are default-constructed (not defined()), which causes
+// BindlessResourceManager to write a dummy descriptor for that slot — safe.
+template<typename BufferType>
+class RetainedBufferTable {
+  struct Key {
+    void*  ptr;
+    size_t offset;
+    size_t length;
+    bool operator==(const Key& o) const noexcept {
+      return ptr == o.ptr && offset == o.offset && length == o.length;
+    }
+  };
+  struct KeyHash {
+    size_t operator()(const Key& k) const noexcept {
+      return dxvk::hashStructByMemory<Key, &Key::ptr, &Key::offset, &Key::length>(k);
+    }
+  };
+
+  static Key makeKey(const BufferType& buffer) {
+    return { static_cast<void*>(buffer.buffer().ptr()), buffer.offset(), buffer.length() };
+  }
+
+public:
+  // Register buffer and return its stable slot index. buffer must be defined().
+  // Increments the ref count if the buffer is already registered.
+  uint32_t acquire(const BufferType& buffer) {
+    assert(buffer.defined());
+    auto [it, inserted] = m_indexMap.emplace(makeKey(buffer), uint32_t(0));
+    if (!inserted) {
+      ++m_refCounts[it->second];
+      return it->second;
+    }
+    uint32_t slot;
+    if (!m_freeSlots.empty()) {
+      slot = m_freeSlots.back();
+      m_freeSlots.pop_back();
+      m_table[slot]     = buffer;
+      m_refCounts[slot] = 1;
+    } else {
+      slot = static_cast<uint32_t>(m_table.size());
+      m_table.push_back(buffer);
+      m_refCounts.push_back(1);
+    }
+    it->second = slot;
+    return slot;
+  }
+
+  // Decrement the ref count for slot. Frees the slot when it reaches zero.
+  // slot must be a value previously returned by acquire() (not a sentinel).
+  void release(uint32_t slot) {
+    if (slot >= m_table.size()) {
+      assert(false && "RetainedBufferTable::release: invalid slot");
+      return;
+    }
+    if (m_refCounts[slot] == 0) {
+      assert(false && "RetainedBufferTable::release: over-release of slot");
+      return;
+    }
+    if (--m_refCounts[slot] == 0) {
+      m_indexMap.erase(makeKey(m_table[slot]));
+      m_table[slot] = BufferType{};
+      m_freeSlots.push_back(slot);
+    }
+  }
+
+  // Returns true if slot is still registered for exactly buffer (same buffer slice).
+  // Returns false if slot is out of range (e.g. kSurfaceInvalidBufferIndex).
+  bool isRegistered(uint32_t slot, const BufferType& buffer) const {
+    if (slot >= m_table.size()) {
+      return false;
+    }
+    return buffer.matches(m_table[slot]);
+  }
+
+  // Reset all registrations. Only call after GPU idle (full scene clear).
+  void clear() {
+    m_indexMap.clear();
+    m_table.clear();
+    m_refCounts.clear();
+    m_freeSlots.clear();
+  }
+
+  const std::vector<BufferType>& getObjectTable() const { return m_table; }
+  uint32_t getActiveCount() const { return static_cast<uint32_t>(m_indexMap.size()); }
+  uint32_t getTotalCount()  const { return static_cast<uint32_t>(m_table.size()); }
+
+private:
+  std::unordered_map<Key, uint32_t, KeyHash> m_indexMap;
+  std::vector<BufferType> m_table;
+  std::vector<uint32_t>   m_refCounts;
+  std::vector<uint32_t>   m_freeSlots;
+};