GPUUploadManager: add parallel updates test

Author: TheMostDiligent

Graphics/GraphicsTools/src/GPUUploadManagerImpl.cpp

@@ -391,21 +391,27 @@ void GPUUploadManagerImpl::ScheduleBufferUpdate(IDeviceContext*               pC
         Page::Writer Writer = P->TryBeginWriting();
         if (!Writer)
         {
+            // The page is sealed, so we need to rotate to a new page and try again
             UpdatePendingSizeAndTryRotate(P);
             continue;
         }
 
         const bool UpdateScheduled = Writer.ScheduleBufferUpdate(pDstBuffer, DstOffset, NumBytes, pSrcData, Callback, pCallbackData);
         if (Writer.EndWriting() == Page::WritingStatus::LastWriterSealed)
         {
-            // We were the last writer
+            // We were the last writer - enqueue the page whether the update was successfully scheduled or not,
+            // because the page is sealed and can't be written to anymore.
             TryEnqueuePage(P);
         }
 
         if (UpdateScheduled)
         {
             if (!IsFirstAttempt)
+            {
+                // If we had to rotate the page at least once, we need to subtract the update size from the total pending update size
+                // as the update was successfully scheduled on the page.
                 m_TotalPendingUpdateSize.fetch_sub(NumBytes, std::memory_order_relaxed);
+            }
             break;
         }
         else

Tests/DiligentCoreAPITest/src/GPUUploadManagerTest.cpp

@@ -48,6 +48,8 @@ TEST(GPUUploadManagerTest, Creation)
     IRenderDevice*         pDevice  = pEnv->GetDevice();
     IDeviceContext*        pContext = pEnv->GetDeviceContext();
 
+    GPUTestingEnvironment::ScopedReset AutoReset;
+
     RefCntAutoPtr<IGPUUploadManager> pUploadManager;
     GPUUploadManagerCreateInfo       CreateInfo{pDevice, pContext};
     CreateGPUUploadManager(CreateInfo, &pUploadManager);
@@ -60,6 +62,8 @@ void VerifyBufferContents(IBuffer* pBuffer, const std::vector<Uint8>& ExpectedDa
     IRenderDevice*         pDevice  = pEnv->GetDevice();
     IDeviceContext*        pContext = pEnv->GetDeviceContext();
 
+    GPUTestingEnvironment::ScopedReset AutoReset;
+
     BufferDesc Desc     = pBuffer->GetDesc();
     Desc.Name           = "GPUUploadManagerTest readback buffer";
     Desc.Usage          = USAGE_STAGING;
@@ -77,6 +81,7 @@ void VerifyBufferContents(IBuffer* pBuffer, const std::vector<Uint8>& ExpectedDa
     void* pBufferData = nullptr;
     pContext->MapBuffer(pReadbackBuffer, MAP_READ, MAP_FLAG_DO_NOT_WAIT, pBufferData);
     ASSERT_NE(pBufferData, nullptr);
+    pContext->UnmapBuffer(pReadbackBuffer, MAP_READ);
 
     EXPECT_TRUE(std::memcmp(pBufferData, ExpectedData.data(), ExpectedData.size()) == 0) << "Buffer contents do not match expected data";
 }
@@ -87,6 +92,8 @@ TEST(GPUUploadManagerTest, ScheduleUpdates)
     IRenderDevice*         pDevice  = pEnv->GetDevice();
     IDeviceContext*        pContext = pEnv->GetDeviceContext();
 
+    GPUTestingEnvironment::ScopedReset AutoReset;
+
     RefCntAutoPtr<IGPUUploadManager> pUploadManager;
     GPUUploadManagerCreateInfo       CreateInfo{pDevice, pContext, 1024};
     CreateGPUUploadManager(CreateInfo, &pUploadManager);
@@ -118,4 +125,96 @@ TEST(GPUUploadManagerTest, ScheduleUpdates)
     VerifyBufferContents(pBuffer, BufferData);
 }
 
+TEST(GPUUploadManagerTest, ParallelUpdates)
+{
+    GPUTestingEnvironment* pEnv     = GPUTestingEnvironment::GetInstance();
+    IRenderDevice*         pDevice  = pEnv->GetDevice();
+    IDeviceContext*        pContext = pEnv->GetDeviceContext();
+
+    RefCntAutoPtr<IGPUUploadManager> pUploadManager;
+    GPUUploadManagerCreateInfo       CreateInfo{pDevice, pContext, 16384};
+    CreateGPUUploadManager(CreateInfo, &pUploadManager);
+    ASSERT_TRUE(pUploadManager != nullptr);
+
+    std::vector<Uint8> BufferData(4 << 20);
+    for (size_t i = 0; i < BufferData.size(); ++i)
+    {
+        BufferData[i] = static_cast<Uint8>(i % 256);
+    }
+
+    BufferDesc Desc;
+    Desc.Name      = "GPUUploadManagerTest buffer";
+    Desc.Size      = BufferData.size();
+    Desc.Usage     = USAGE_DEFAULT;
+    Desc.BindFlags = BIND_VERTEX_BUFFER;
+
+    RefCntAutoPtr<IBuffer> pBuffer;
+    pDevice->CreateBuffer(Desc, nullptr, &pBuffer);
+    ASSERT_TRUE(pBuffer);
+
+    const size_t kNumThreads = std::max(2u, std::thread::hardware_concurrency() - 1);
+    LOG_INFO_MESSAGE("Number of threads: ", kNumThreads);
+
+    std::atomic<Uint32> CurrOffset{0};
+    std::atomic<Uint32> NumUpdatesScheduled{0};
+    std::atomic<Uint32> NumThreadsCompleted{0};
+
+    std::vector<std::thread> Threads;
+    for (size_t t = 0; t < kNumThreads; ++t)
+    {
+        Threads.emplace_back(
+            [&]() {
+                while (true)
+                {
+                    const Uint32 UpdateSize = 64;
+
+                    Uint32 Offset = CurrOffset.fetch_add(UpdateSize);
+                    if (Offset >= BufferData.size())
+                        break;
+                    pUploadManager->ScheduleBufferUpdate(nullptr, pBuffer, Offset, UpdateSize, &BufferData[Offset]);
+                    NumUpdatesScheduled.fetch_add(1);
+                }
+                NumThreadsCompleted.fetch_add(1);
+            });
+    }
+
+    const Uint32 NumUpdatesToRenderThreadUpdate = 256;
+
+    Uint32 LastNumUpdatesScheduled    = 0;
+    Uint32 NumIterationsWithoutUpdate = 0;
+    Uint32 NumRenderThreadUpdates     = 0;
+    while (NumThreadsCompleted.load() < kNumThreads)
+    {
+        if (LastNumUpdatesScheduled == NumUpdatesScheduled.load())
+        {
+            ++NumIterationsWithoutUpdate;
+        }
+        else
+        {
+            LastNumUpdatesScheduled    = NumUpdatesScheduled.load();
+            NumIterationsWithoutUpdate = 0;
+        }
+
+        if (NumUpdatesScheduled.load() >= NumUpdatesToRenderThreadUpdate || NumIterationsWithoutUpdate >= 100)
+        {
+            pUploadManager->RenderThreadUpdate(pContext);
+            NumUpdatesScheduled.fetch_sub(NumUpdatesToRenderThreadUpdate);
+            pContext->Flush();
+            pContext->FinishFrame();
+            ++NumRenderThreadUpdates;
+        }
+    }
+
+    LOG_INFO_MESSAGE("Total render thread updates: ", NumRenderThreadUpdates);
+
+    pUploadManager->RenderThreadUpdate(pContext);
+
+    for (std::thread& thread : Threads)
+    {
+        thread.join();
+    }
+
+    VerifyBufferContents(pBuffer, BufferData);
+}
+
 } // namespace