GPUUploadManagerImpl::Page: support persistent mapping

Add GPUUploadManager creation test.

Author: TheMostDiligent

Graphics/GraphicsTools/include/GPUUploadManagerImpl.hpp

@@ -63,7 +63,7 @@ class GPUUploadManagerImpl final : public ObjectBase<IGPUUploadManager>
     class Page
     {
     public:
-        explicit Page(Uint32 Size) noexcept;
+        explicit Page(Uint32 Size, bool PersistentMapped = false) noexcept;
 
         Page(IRenderDevice*  pDevice,
              IDeviceContext* pContext,
@@ -149,6 +149,8 @@ class GPUUploadManagerImpl final : public ObjectBase<IGPUUploadManager>
         // Returns true if the page is sealed for new writes. This is used for testing and debugging purposes.
         bool DbgIsSealed() const { return (m_State.load(std::memory_order_relaxed) & SEALED_BIT) != 0; }
 
+        void ReleaseStagingBuffer(IDeviceContext* pContext);
+
     private:
         // Schedules a buffer update operation on the page.
         // Returns true if the operation was successfully scheduled, and false otherwise.
@@ -162,7 +164,8 @@ class GPUUploadManagerImpl final : public ObjectBase<IGPUUploadManager>
         WritingStatus EndWriting();
 
     private:
-        const Uint32 m_Size = 0;
+        const Uint32 m_Size             = 0;
+        const bool   m_PersistentMapped = false;
 
         RefCntAutoPtr<IBuffer> m_pStagingBuffer;
 
@@ -202,7 +205,8 @@ class GPUUploadManagerImpl final : public ObjectBase<IGPUUploadManager>
 private:
     const Uint32 m_PageSize;
 
-    RefCntAutoPtr<IRenderDevice> m_pDevice;
+    RefCntAutoPtr<IRenderDevice>  m_pDevice;
+    RefCntAutoPtr<IDeviceContext> m_pContext;
 
     // Pages that are pending for execution.
     MPSCQueue<Page*> m_PendingPages;

Graphics/GraphicsTools/src/GPUUploadManagerImpl.cpp

@@ -80,14 +80,24 @@ GPUUploadManagerImpl::Page::Writer::~Writer()
     }
 }
 
-GPUUploadManagerImpl::Page::Page(Uint32 Size) noexcept :
-    m_Size{Size}
+GPUUploadManagerImpl::Page::Page(Uint32 Size, bool PersistentMapped) noexcept :
+    m_Size{Size},
+    m_PersistentMapped{PersistentMapped}
 {}
 
+inline bool PersistentMapSupported(IRenderDevice* pDevice)
+{
+    RENDER_DEVICE_TYPE DeviceType = pDevice->GetDeviceInfo().Type;
+    return DeviceType == RENDER_DEVICE_TYPE_D3D12 || DeviceType == RENDER_DEVICE_TYPE_VULKAN;
+}
+
 GPUUploadManagerImpl::Page::Page(IRenderDevice*  pDevice,
                                  IDeviceContext* pContext,
                                  Uint32          Size) :
-    Page{Size}
+    Page{
+        Size,
+        PersistentMapSupported(pDevice),
+    }
 {
     static std::atomic<int> PageCounter{0};
     const std::string       Name = "GPUUploadManagerImpl page " + std::to_string(PageCounter.fetch_add(1));
@@ -221,7 +231,7 @@ void GPUUploadManagerImpl::Page::ExecutePendingOps(IDeviceContext* pContext, Uin
     VERIFY(DbgIsSealed(), "Page must be sealed before executing pending operations");
     VERIFY(DbgGetWriterCount() == 0, "All writers must finish before executing pending operations");
 
-    if (m_pData != nullptr)
+    if (m_pData != nullptr && !m_PersistentMapped)
     {
         VERIFY_EXPR(pContext != nullptr);
         pContext->UnmapBuffer(m_pStagingBuffer, MAP_WRITE);
@@ -258,7 +268,10 @@ void GPUUploadManagerImpl::Page::Reset(IDeviceContext* pContext)
 
     if (pContext != nullptr)
     {
-        pContext->MapBuffer(m_pStagingBuffer, MAP_WRITE, MAP_FLAG_NONE, m_pData);
+        if (!m_PersistentMapped)
+        {
+            pContext->MapBuffer(m_pStagingBuffer, MAP_WRITE, MAP_FLAG_NONE, m_pData);
+        }
         VERIFY_EXPR(m_pData != nullptr);
     }
 }
@@ -272,11 +285,23 @@ bool GPUUploadManagerImpl::Page::TryEnqueue()
     return m_Enqueued.compare_exchange_strong(Expected, true, std::memory_order_acq_rel);
 }
 
+void GPUUploadManagerImpl::Page::ReleaseStagingBuffer(IDeviceContext* pContext)
+{
+    if (m_pData != nullptr)
+    {
+        VERIFY_EXPR(pContext != nullptr);
+        pContext->UnmapBuffer(m_pStagingBuffer, MAP_WRITE);
+        m_pData = nullptr;
+    }
+    m_pStagingBuffer.Release();
+}
+
 
 GPUUploadManagerImpl::GPUUploadManagerImpl(IReferenceCounters* pRefCounters, const GPUUploadManagerCreateInfo& CI) :
     TBase{pRefCounters},
     m_PageSize{AlignUpToPowerOfTwo(CI.PageSize)},
-    m_pDevice{CI.pDevice}
+    m_pDevice{CI.pDevice},
+    m_pContext{CI.pContext}
 {
     FenceDesc Desc;
     Desc.Name = "GPU upload manager fence";
@@ -289,11 +314,17 @@ GPUUploadManagerImpl::GPUUploadManagerImpl(IReferenceCounters* pRefCounters, con
 
 GPUUploadManagerImpl::~GPUUploadManagerImpl()
 {
+    for (std::unique_ptr<Page>& P : m_Pages)
+    {
+        P->ReleaseStagingBuffer(m_pContext);
+    }
 }
 
 void GPUUploadManagerImpl::RenderThreadUpdate(IDeviceContext* pContext)
 {
+    DEV_CHECK_ERR(pContext == m_pContext, "The context passed to RenderThreadUpdate must be the same as the one used to create the GPUUploadManagerImpl");
     (void)m_NextFenceValue;
+    (void)m_FreePagesMtx;
 }
 
 void GPUUploadManagerImpl::ScheduleBufferUpdate(IBuffer*                      pDstBuffer,

Tests/DiligentCoreAPITest/src/GPUUploadManagerTest.cpp

@@ -0,0 +1,56 @@
+/*
+ *  Copyright 2026 Diligent Graphics LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#include "GPUUploadManager.h"
+#include "GPUTestingEnvironment.hpp"
+#include "ThreadSignal.hpp"
+#include "CallbackWrapper.hpp"
+
+#include "gtest/gtest.h"
+
+#include <atomic>
+#include <thread>
+#include <array>
+
+using namespace Diligent;
+using namespace Diligent::Testing;
+
+namespace
+{
+
+TEST(GPUUploadManagerTest, Creation)
+{
+    GPUTestingEnvironment* pEnv     = GPUTestingEnvironment::GetInstance();
+    IRenderDevice*         pDevice  = pEnv->GetDevice();
+    IDeviceContext*        pContext = pEnv->GetDeviceContext();
+
+    RefCntAutoPtr<IGPUUploadManager> pUploadManager;
+    GPUUploadManagerCreateInfo       CreateInfo{pDevice, pContext};
+    CreateGPUUploadManager(CreateInfo, &pUploadManager);
+    ASSERT_TRUE(pUploadManager != nullptr);
+}
+
+} // namespace