DynamicTextureArray: avoid empty sparse resize binds

Treat page-aligned sparse resizes that preserve resident capacity as no-ops
and document that sparse array size reports page-aligned capacity.

Author: TheMostDiligent

Graphics/GraphicsTools/interface/DynamicTextureArray.hpp

@@ -117,6 +117,10 @@ class DynamicTextureArray
     ///
     /// Typically `pContext` is null when the method is called from a worker thread.
     ///
+    /// For a sparse texture, `NewArraySize` is rounded up to a multiple of
+    /// DynamicTextureArrayCreateInfo::NumSlicesInMemoryPage. GetArraySize()
+    /// reports this committed page-aligned resident capacity.
+    ///
     /// While a content-preserving resize of a default texture is pending, the
     /// method may only be called with the same `NewArraySize`, for example to
     /// provide a device or context that was previously unavailable. A different
@@ -197,6 +201,9 @@ class DynamicTextureArray
 
     /// Returns the current number of slices in the texture array.
     ///
+    /// For a sparse texture, this is the committed page-aligned resident
+    /// capacity and may be greater than the size passed to Resize().
+    ///
     /// \remarks The method is thread-safe and may be called from worker threads.
     ///          If it races with Update() or Resize(), the returned value may
     ///          become stale immediately.

Graphics/GraphicsTools/src/DynamicTextureArray.cpp

@@ -324,11 +324,24 @@ ITextureView* DynamicTextureArray::GetTextureSRV(TEXTURE_FORMAT ViewFormat) cons
 
 bool DynamicTextureArray::ResizeSparseTexture(IDeviceContext* pContext)
 {
-    const Uint32 CurrArraySize = GetArraySize();
-    VERIFY_EXPR(m_PendingSize != CurrArraySize);
+    const Uint32 CurrResidentSize = GetArraySize();
+    VERIFY_EXPR(m_PendingSize != CurrResidentSize);
     VERIFY_EXPR(m_pTexture && m_pMemory);
 
-    m_PendingSize = AlignUp(m_PendingSize, m_NumSlicesInPage);
+    const Uint64 ResidentSize = AlignUp(Uint64{m_PendingSize}, Uint64{m_NumSlicesInPage});
+    if (ResidentSize > m_pTexture->GetDesc().ArraySize)
+    {
+        LOG_ERROR_MESSAGE("Requested sparse dynamic texture array size exceeds the texture capacity after page alignment");
+        return false;
+    }
+
+    m_PendingSize = StaticCast<Uint32>(ResidentSize);
+    if (m_PendingSize == CurrResidentSize)
+    {
+        // The logical request fits in the currently resident page range. There
+        // are no memory ranges to bind or unbind.
+        return true;
+    }
 
     const Uint64 RequiredMemSize = (m_PendingSize / m_NumSlicesInPage) * m_MemoryPageSize;
     if (RequiredMemSize > m_pMemory->GetCapacity())
@@ -347,11 +360,11 @@ bool DynamicTextureArray::ResizeSparseTexture(IDeviceContext* pContext)
         }
     }
 
-    const Uint32 NumSlicesToBind = m_PendingSize > CurrArraySize ?
-        m_PendingSize - CurrArraySize :
-        CurrArraySize - m_PendingSize;
+    const Uint32 NumSlicesToBind = m_PendingSize > CurrResidentSize ?
+        m_PendingSize - CurrResidentSize :
+        CurrResidentSize - m_PendingSize;
 
-    Uint64 CurrMemOffset = Uint64{(m_PendingSize > CurrArraySize ? CurrArraySize : m_PendingSize) / m_NumSlicesInPage} * m_MemoryPageSize;
+    Uint64 CurrMemOffset = Uint64{(m_PendingSize > CurrResidentSize ? CurrResidentSize : m_PendingSize) / m_NumSlicesInPage} * m_MemoryPageSize;
 
     const SparseTextureProperties& TexSparseProps = m_pTexture->GetSparseProperties();
     const Uint32                   NumNormalMips  = std::min(m_Desc.MipLevels, TexSparseProps.FirstMipInTail);
@@ -362,8 +375,8 @@ bool DynamicTextureArray::ResizeSparseTexture(IDeviceContext* pContext)
     std::vector<SparseTextureMemoryBindRange> MipRanges(size_t{NumSlicesToBind} * (size_t{NumNormalMips} + (HasMipTail ? 1 : 0)));
 
     auto   range_it   = MipRanges.begin();
-    Uint32 StartSlice = std::min(CurrArraySize, m_PendingSize);
-    Uint32 EndSlice   = std::max(CurrArraySize, m_PendingSize);
+    Uint32 StartSlice = std::min(CurrResidentSize, m_PendingSize);
+    Uint32 EndSlice   = std::max(CurrResidentSize, m_PendingSize);
     for (Uint32 Slice = StartSlice; Slice != EndSlice; ++Slice)
     {
         // Bind normal mip levels
@@ -380,7 +393,7 @@ bool DynamicTextureArray::ResizeSparseTexture(IDeviceContext* pContext)
                 range_it->MipLevel   = Mip;
                 range_it->Region     = Box{0, MipProps.StorageWidth, 0, MipProps.StorageHeight, 0, MipProps.Depth};
 
-                if (Slice >= CurrArraySize)
+                if (Slice >= CurrResidentSize)
                 {
                     const uint3 NumTilesInMip = GetNumSparseTilesInBox(range_it->Region, TexSparseProps.TileSize);
                     range_it->pMemory         = m_pMemory;
@@ -410,7 +423,7 @@ bool DynamicTextureArray::ResizeSparseTexture(IDeviceContext* pContext)
             range_it->MipLevel   = TexSparseProps.FirstMipInTail;
             range_it->MemorySize = TexSparseProps.MipTailSize;
 
-            if (Slice >= CurrArraySize)
+            if (Slice >= CurrResidentSize)
             {
                 range_it->pMemory      = m_pMemory;
                 range_it->MemoryOffset = CurrMemOffset;
@@ -551,7 +564,7 @@ void DynamicTextureArray::CommitResize(IRenderDevice*  pDevice,
             ResizeCommitted = true;
         }
 
-        if (ResizeCommitted)
+        if (ResizeCommitted && m_PendingSize != CurrArraySize)
         {
             StoreArraySize(m_PendingSize);
 

Tests/DiligentCoreAPITest/src/DynamicTextureArrayTest.cpp

@@ -289,9 +289,6 @@ TEST(DynamicTextureArray, ResizeToZeroBeforeInitialization)
     EXPECT_EQ(TextureArray.GetTexture(), nullptr);
 }
 
-
-
-
 class DynamicTextureArrayResizeTest : public testing::TestWithParam<std::tuple<USAGE, TEXTURE_FORMAT>>
 {
 };
@@ -439,6 +436,17 @@ TEST_P(DynamicTextureArrayResizeTest, Run)
     UpdateSlice(pContext, pTexture, 0);
     VerifySlices(pContext, pTexture, 0, 1);
 
+    if (Usage == USAGE_SPARSE)
+    {
+        ASSERT_EQ(pDynTexArray->GetArraySize(), DynTexArrCI.NumSlicesInMemoryPage);
+
+        // One requested slice still requires the same two-slice resident page,
+        // so the resize completes without issuing an empty sparse bind.
+        EXPECT_EQ(pDynTexArray->Resize(nullptr, pContext, 1), pTexture);
+        EXPECT_FALSE(pDynTexArray->PendingUpdate());
+        EXPECT_EQ(pDynTexArray->GetArraySize(), DynTexArrCI.NumSlicesInMemoryPage);
+    }
+
     pDynTexArray->Resize(pDevice, pContext, 2);
     pTexture = pDynTexArray->Update(nullptr, nullptr);
     EXPECT_EQ(pTexture, pDynTexArray->GetTexture());