Render state cache: fixed asynchronous pipelines reloading

Author: TheMostDiligent

Graphics/GraphicsTools/include/ReloadablePipelineState.hpp

@@ -61,13 +61,18 @@ class ReloadablePipelineState final : public ProxyPipelineState<ObjectBase<IPipe
 
     virtual void DILIGENT_CALL_TYPE QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface) override final;
 
+    virtual PIPELINE_STATE_STATUS DILIGENT_CALL_TYPE GetStatus(bool WaitForCompletion) override;
+
     static void Create(RenderStateCacheImpl*          pStateCache,
                        IPipelineState*                pPipeline,
                        const PipelineStateCreateInfo& CreateInfo,
                        IPipelineState**               ppReloadablePipeline);
 
     bool Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData);
 
+private:
+    void CopyStaticResources();
+
 private:
     template <typename CreateInfoType>
     bool Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData);
@@ -80,6 +85,9 @@ class ReloadablePipelineState final : public ProxyPipelineState<ObjectBase<IPipe
     RefCntAutoPtr<RenderStateCacheImpl>    m_pStateCache;
     std::unique_ptr<CreateInfoWrapperBase> m_pCreateInfo;
     const PIPELINE_TYPE                    m_Type;
+
+    // Old pipeline state kept around to copy static resources from
+    RefCntAutoPtr<IPipelineState> m_pOldPipeline;
 };
 
 } // namespace Diligent

Graphics/GraphicsTools/src/ReloadablePipelineState.cpp

@@ -168,23 +168,19 @@ bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGr
     {
         if (m_pPipeline != pNewPSO)
         {
-            const auto SrcSignCount = m_pPipeline->GetResourceSignatureCount();
-            const auto DstSignCount = pNewPSO->GetResourceSignatureCount();
-            if (SrcSignCount == DstSignCount)
+            // Do not update old pipeline if it is not null.
+            // If multiple reloads are requested, we need to keep the original pipeline that keeps the original resources.
+            if (!m_pOldPipeline)
             {
-                for (Uint32 s = 0; s < SrcSignCount; ++s)
-                {
-                    auto* pSrcSign = m_pPipeline->GetResourceSignature(s);
-                    auto* pDstSign = pNewPSO->GetResourceSignature(s);
-                    if (pSrcSign != pDstSign)
-                        pSrcSign->CopyStaticResources(pDstSign);
-                }
+                m_pOldPipeline = m_pPipeline;
             }
-            else
+            m_pPipeline = pNewPSO;
+
+            // If any of the pipelines is not ready, we will copy static resources when both are ready in GetStatus()
+            if (m_pPipeline->GetStatus() == PIPELINE_STATE_STATUS_READY && m_pOldPipeline->GetStatus() == PIPELINE_STATE_STATUS_READY)
             {
-                UNEXPECTED("The number of resource signatures in old pipeline (", SrcSignCount, ") does not match the number of signatures in new pipeline (", DstSignCount, ")");
+                CopyStaticResources();
             }
-            m_pPipeline = pNewPSO;
         }
     }
     else
@@ -195,6 +191,58 @@ bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGr
     return !FoundInCache;
 }
 
+void ReloadablePipelineState::CopyStaticResources()
+{
+    const Uint32 SrcSignCount = m_pOldPipeline->GetResourceSignatureCount();
+    const Uint32 DstSignCount = m_pPipeline->GetResourceSignatureCount();
+    if (SrcSignCount == DstSignCount)
+    {
+        for (Uint32 s = 0; s < SrcSignCount; ++s)
+        {
+            IPipelineResourceSignature* pSrcSign = m_pOldPipeline->GetResourceSignature(s);
+            IPipelineResourceSignature* pDstSign = m_pPipeline->GetResourceSignature(s);
+            if (pSrcSign != pDstSign)
+            {
+                pSrcSign->CopyStaticResources(pDstSign);
+            }
+        }
+    }
+    else
+    {
+        UNEXPECTED("The number of resource signatures in old pipeline (", SrcSignCount, ") does not match the number of signatures in new pipeline (", DstSignCount, ")");
+    }
+    m_pOldPipeline.Release();
+}
+
+
+PIPELINE_STATE_STATUS ReloadablePipelineState::GetStatus(bool WaitForCompletion)
+{
+    const PIPELINE_STATE_STATUS Status = m_pPipeline ? m_pPipeline->GetStatus(WaitForCompletion) : PIPELINE_STATE_STATUS_FAILED;
+    if (Status != PIPELINE_STATE_STATUS_READY)
+        return Status;
+
+    if (m_pOldPipeline)
+    {
+        const PIPELINE_STATE_STATUS OldPsoStatus = m_pOldPipeline->GetStatus(WaitForCompletion);
+        if (OldPsoStatus == PIPELINE_STATE_STATUS_READY && Status == PIPELINE_STATE_STATUS_READY)
+        {
+            CopyStaticResources();
+        }
+        else if (OldPsoStatus == PIPELINE_STATE_STATUS_COMPILING)
+        {
+            // Wait until the old pipeline is ready
+            return PIPELINE_STATE_STATUS_COMPILING;
+        }
+        else if (OldPsoStatus == PIPELINE_STATE_STATUS_FAILED)
+        {
+            LOG_ERROR_MESSAGE("Failed to copy static resources from the old pipeline after reloading pipeline state '", m_pPipeline->GetDesc().Name,
+                              "'. Old pipeline is in the failed state.");
+            m_pOldPipeline.Release();
+        }
+    }
+
+    return Status;
+}
 
 bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)
 {