SetPipelineState: eliminated redundant calls to AddRef/Release

TheMostDiligent · TheMostDiligent · commit 799fc529fd30 · 2022-10-25T19:41:44.000-07:00
diff --git a/Graphics/GraphicsEngine/include/DeviceContextBase.hpp b/Graphics/GraphicsEngine/include/DeviceContextBase.hpp
@@ -451,7 +451,7 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
 
     inline bool SetStencilRef(Uint32 StencilRef, int Dummy);
 
-    inline void SetPipelineState(PipelineStateImplType* pPipelineState, int /*Dummy*/);
+    inline void SetPipelineState(RefCntAutoPtr<PipelineStateImplType> pPipelineState, int /*Dummy*/);
 
     /// Clears all cached resources
     inline void ClearStateCache();
@@ -754,14 +754,14 @@ inline void DeviceContextBase<ImplementationTraits>::SetVertexBuffers(
 
 template <typename ImplementationTraits>
 inline void DeviceContextBase<ImplementationTraits>::SetPipelineState(
-    PipelineStateImplType* pPipelineState,
+    RefCntAutoPtr<PipelineStateImplType> pPipelineState,
     int /*Dummy*/)
 {
     DVP_CHECK_QUEUE_TYPE_COMPATIBILITY(COMMAND_QUEUE_TYPE_COMPUTE, "SetPipelineState");
     DEV_CHECK_ERR((pPipelineState->GetDesc().ImmediateContextMask & (Uint64{1} << GetExecutionCtxId())) != 0,
                   "PSO '", pPipelineState->GetDesc().Name, "' can't be used in device context '", m_Desc.Name, "'.");
 
-    m_pPipelineState = pPipelineState;
+    m_pPipelineState = std::move(pPipelineState);
 }
 
 template <typename ImplementationTraits>
diff --git a/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp
@@ -83,11 +83,11 @@ void DeviceContextD3D11Impl::SetPipelineState(IPipelineState* pPipelineState)
     if (PipelineStateD3D11Impl::IsSameObject(m_pPipelineState, pPipelineStateD3D11))
         return;
 
-    TDeviceContextBase::SetPipelineState(pPipelineStateD3D11, 0 /*Dummy*/);
-    const auto& Desc = pPipelineStateD3D11->GetDesc();
+    TDeviceContextBase::SetPipelineState(std::move(pPipelineStateD3D11), 0 /*Dummy*/);
+    const auto& Desc = m_pPipelineState->GetDesc();
     if (Desc.PipelineType == PIPELINE_TYPE_COMPUTE)
     {
-        auto* pd3d11CS = pPipelineStateD3D11->GetD3D11ComputeShader();
+        auto* pd3d11CS = m_pPipelineState->GetD3D11ComputeShader();
         if (pd3d11CS == nullptr)
         {
             LOG_ERROR("Compute shader is not set in the pipeline");
@@ -97,7 +97,7 @@ void DeviceContextD3D11Impl::SetPipelineState(IPipelineState* pPipelineState)
 #define COMMIT_SHADER(SN, ShaderName)                                       \
     do                                                                      \
     {                                                                       \
-        auto* pd3d11Shader = pPipelineStateD3D11->GetD3D11##ShaderName();   \
+        auto* pd3d11Shader = m_pPipelineState->GetD3D11##ShaderName();      \
         if (m_CommittedD3DShaders[SN##Ind] != pd3d11Shader)                 \
         {                                                                   \
             m_CommittedD3DShaders[SN##Ind] = pd3d11Shader;                  \
@@ -116,13 +116,13 @@ void DeviceContextD3D11Impl::SetPipelineState(IPipelineState* pPipelineState)
         COMMIT_SHADER(DS, DomainShader);
 #undef COMMIT_SHADER
 
-        const auto& GraphicsPipeline = pPipelineStateD3D11->GetGraphicsPipelineDesc();
+        const auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();
 
-        m_pd3d11DeviceContext->OMSetBlendState(pPipelineStateD3D11->GetD3D11BlendState(), m_BlendFactors, GraphicsPipeline.SampleMask);
-        m_pd3d11DeviceContext->RSSetState(pPipelineStateD3D11->GetD3D11RasterizerState());
-        m_pd3d11DeviceContext->OMSetDepthStencilState(pPipelineStateD3D11->GetD3D11DepthStencilState(), m_StencilRef);
+        m_pd3d11DeviceContext->OMSetBlendState(m_pPipelineState->GetD3D11BlendState(), m_BlendFactors, GraphicsPipeline.SampleMask);
+        m_pd3d11DeviceContext->RSSetState(m_pPipelineState->GetD3D11RasterizerState());
+        m_pd3d11DeviceContext->OMSetDepthStencilState(m_pPipelineState->GetD3D11DepthStencilState(), m_StencilRef);
 
-        auto* pd3d11InputLayout = pPipelineStateD3D11->GetD3D11InputLayout();
+        auto* pd3d11InputLayout = m_pPipelineState->GetD3D11InputLayout();
         // It is safe to perform raw pointer comparison as the device context
         // keeps bound input layout alive
         if (m_CommittedD3D11InputLayout != pd3d11InputLayout)
diff --git a/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
@@ -293,11 +293,11 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)
             CommitScissor = m_pPipelineState->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable != pPipelineStateD3D12->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable;
     }
 
-    TDeviceContextBase::SetPipelineState(pPipelineStateD3D12, 0 /*Dummy*/);
+    TDeviceContextBase::SetPipelineState(std::move(pPipelineStateD3D12), 0 /*Dummy*/);
 
     auto& CmdCtx        = GetCmdContext();
     auto& RootInfo      = GetRootTableInfo(PSODesc.PipelineType);
-    auto* pd3d12RootSig = pPipelineStateD3D12->GetD3D12RootSignature();
+    auto* pd3d12RootSig = m_pPipelineState->GetD3D12RootSignature();
 
     if (RootInfo.pd3d12RootSig != pd3d12RootSig)
     {
@@ -316,9 +316,9 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)
         case PIPELINE_TYPE_GRAPHICS:
         case PIPELINE_TYPE_MESH:
         {
-            auto& GraphicsPipeline = pPipelineStateD3D12->GetGraphicsPipelineDesc();
+            auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();
             auto& GraphicsCtx      = CmdCtx.AsGraphicsContext();
-            auto* pd3d12PSO        = pPipelineStateD3D12->GetD3D12PipelineState();
+            auto* pd3d12PSO        = m_pPipelineState->GetD3D12PipelineState();
             GraphicsCtx.SetPipelineState(pd3d12PSO);
             GraphicsCtx.SetGraphicsRootSignature(pd3d12RootSig);
 
@@ -347,15 +347,15 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)
         }
         case PIPELINE_TYPE_COMPUTE:
         {
-            auto* pd3d12PSO = pPipelineStateD3D12->GetD3D12PipelineState();
+            auto* pd3d12PSO = m_pPipelineState->GetD3D12PipelineState();
             auto& CompCtx   = CmdCtx.AsComputeContext();
             CompCtx.SetPipelineState(pd3d12PSO);
             CompCtx.SetComputeRootSignature(pd3d12RootSig);
             break;
         }
         case PIPELINE_TYPE_RAY_TRACING:
         {
-            auto* pd3d12SO = pPipelineStateD3D12->GetD3D12StateObject();
+            auto* pd3d12SO = m_pPipelineState->GetD3D12StateObject();
             auto& RTCtx    = CmdCtx.AsGraphicsContext4();
             RTCtx.SetRayTracingPipelineState(pd3d12SO);
             RTCtx.SetComputeRootSignature(pd3d12RootSig);
diff --git a/Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/DeviceContextGLImpl.cpp
@@ -94,15 +94,15 @@ void DeviceContextGLImpl::SetPipelineState(IPipelineState* pPipelineState)
     if (PipelineStateGLImpl::IsSameObject(m_pPipelineState, pPipelineStateGLImpl))
         return;
 
-    TDeviceContextBase::SetPipelineState(pPipelineStateGLImpl, 0 /*Dummy*/);
+    TDeviceContextBase::SetPipelineState(std::move(pPipelineStateGLImpl), 0 /*Dummy*/);
 
-    const auto& Desc = pPipelineStateGLImpl->GetDesc();
+    const auto& Desc = m_pPipelineState->GetDesc();
     if (Desc.PipelineType == PIPELINE_TYPE_COMPUTE)
     {
     }
     else if (Desc.PipelineType == PIPELINE_TYPE_GRAPHICS)
     {
-        const auto& GraphicsPipeline = pPipelineStateGLImpl->GetGraphicsPipelineDesc();
+        const auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();
         // Set rasterizer state
         {
             const auto& RasterizerDesc = GraphicsPipeline.RasterizerDesc;
diff --git a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp
@@ -303,18 +303,18 @@ void DeviceContextVkImpl::SetPipelineState(IPipelineState* pPipelineState)
             CommitScissor = !m_pPipelineState->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable;
     }
 
-    TDeviceContextBase::SetPipelineState(pPipelineStateVk, 0 /*Dummy*/);
+    TDeviceContextBase::SetPipelineState(std::move(pPipelineStateVk), 0 /*Dummy*/);
     EnsureVkCmdBuffer();
 
-    auto vkPipeline = pPipelineStateVk->GetVkPipeline();
+    auto vkPipeline = m_pPipelineState->GetVkPipeline();
 
     static_assert(PIPELINE_TYPE_LAST == 4, "Please update the switch below to handle the new pipeline type");
     switch (PSODesc.PipelineType)
     {
         case PIPELINE_TYPE_GRAPHICS:
         case PIPELINE_TYPE_MESH:
         {
-            auto& GraphicsPipeline = pPipelineStateVk->GetGraphicsPipelineDesc();
+            auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();
             m_CommandBuffer.BindGraphicsPipeline(vkPipeline);
 
             if (CommitStates)
@@ -350,8 +350,8 @@ void DeviceContextVkImpl::SetPipelineState(IPipelineState* pPipelineState)
             UNEXPECTED("unknown pipeline type");
     }
 
-    const auto& Layout    = pPipelineStateVk->GetPipelineLayout();
-    const auto  SignCount = pPipelineStateVk->GetResourceSignatureCount();
+    const auto& Layout    = m_pPipelineState->GetPipelineLayout();
+    const auto  SignCount = m_pPipelineState->GetResourceSignatureCount();
     auto&       BindInfo  = GetBindInfo(PSODesc.PipelineType);
 
     Uint32 DvpCompatibleSRBCount = 0;
@@ -371,7 +371,7 @@ void DeviceContextVkImpl::SetPipelineState(IPipelineState* pPipelineState)
     {
         auto& SetInfo = BindInfo.SetInfo[i];
 
-        auto* pSignature = pPipelineStateVk->GetResourceSignature(i);
+        auto* pSignature = m_pPipelineState->GetResourceSignature(i);
         if (pSignature == nullptr || pSignature->GetNumDescriptorSets() == 0)
         {
             SetInfo = {};

Original file line number	Diff line number	Diff line change
`@@ -293,11 +293,11 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)`
`293`	`293`	`CommitScissor = m_pPipelineState->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable != pPipelineStateD3D12->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable;`
`294`	`294`	`}`
`295`	`295`
`296`		`- TDeviceContextBase::SetPipelineState(pPipelineStateD3D12, 0 /Dummy/);`
	`296`	`+ TDeviceContextBase::SetPipelineState(std::move(pPipelineStateD3D12), 0 /Dummy/);`
`297`	`297`
`298`	`298`	`auto& CmdCtx = GetCmdContext();`
`299`	`299`	`auto& RootInfo = GetRootTableInfo(PSODesc.PipelineType);`
`300`		`- auto* pd3d12RootSig = pPipelineStateD3D12->GetD3D12RootSignature();`
	`300`	`+ auto* pd3d12RootSig = m_pPipelineState->GetD3D12RootSignature();`
`301`	`301`
`302`	`302`	`if (RootInfo.pd3d12RootSig != pd3d12RootSig)`
`303`	`303`	`{`
`@@ -316,9 +316,9 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)`
`316`	`316`	`case PIPELINE_TYPE_GRAPHICS:`
`317`	`317`	`case PIPELINE_TYPE_MESH:`
`318`	`318`	`{`
`319`		`- auto& GraphicsPipeline = pPipelineStateD3D12->GetGraphicsPipelineDesc();`
	`319`	`+ auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();`
`320`	`320`	`auto& GraphicsCtx = CmdCtx.AsGraphicsContext();`
`321`		`- auto* pd3d12PSO = pPipelineStateD3D12->GetD3D12PipelineState();`
	`321`	`+ auto* pd3d12PSO = m_pPipelineState->GetD3D12PipelineState();`
`322`	`322`	`GraphicsCtx.SetPipelineState(pd3d12PSO);`
`323`	`323`	`GraphicsCtx.SetGraphicsRootSignature(pd3d12RootSig);`
`324`	`324`
`@@ -347,15 +347,15 @@ void DeviceContextD3D12Impl::SetPipelineState(IPipelineState* pPipelineState)`
`347`	`347`	`}`
`348`	`348`	`case PIPELINE_TYPE_COMPUTE:`
`349`	`349`	`{`
`350`		`- auto* pd3d12PSO = pPipelineStateD3D12->GetD3D12PipelineState();`
	`350`	`+ auto* pd3d12PSO = m_pPipelineState->GetD3D12PipelineState();`
`351`	`351`	`auto& CompCtx = CmdCtx.AsComputeContext();`
`352`	`352`	`CompCtx.SetPipelineState(pd3d12PSO);`
`353`	`353`	`CompCtx.SetComputeRootSignature(pd3d12RootSig);`
`354`	`354`	`break;`
`355`	`355`	`}`
`356`	`356`	`case PIPELINE_TYPE_RAY_TRACING:`
`357`	`357`	`{`
`358`		`- auto* pd3d12SO = pPipelineStateD3D12->GetD3D12StateObject();`
	`358`	`+ auto* pd3d12SO = m_pPipelineState->GetD3D12StateObject();`
`359`	`359`	`auto& RTCtx = CmdCtx.AsGraphicsContext4();`
`360`	`360`	`RTCtx.SetRayTracingPipelineState(pd3d12SO);`
`361`	`361`	`RTCtx.SetComputeRootSignature(pd3d12RootSig);`
Original file line number	Diff line number	Diff line change
`@@ -94,15 +94,15 @@ void DeviceContextGLImpl::SetPipelineState(IPipelineState* pPipelineState)`
`94`	`94`	`if (PipelineStateGLImpl::IsSameObject(m_pPipelineState, pPipelineStateGLImpl))`
`95`	`95`	`return;`
`96`	`96`
`97`		`- TDeviceContextBase::SetPipelineState(pPipelineStateGLImpl, 0 /Dummy/);`
	`97`	`+ TDeviceContextBase::SetPipelineState(std::move(pPipelineStateGLImpl), 0 /Dummy/);`
`98`	`98`
`99`		`- const auto& Desc = pPipelineStateGLImpl->GetDesc();`
	`99`	`+ const auto& Desc = m_pPipelineState->GetDesc();`
`100`	`100`	`if (Desc.PipelineType == PIPELINE_TYPE_COMPUTE)`
`101`	`101`	`{`
`102`	`102`	`}`
`103`	`103`	`else if (Desc.PipelineType == PIPELINE_TYPE_GRAPHICS)`
`104`	`104`	`{`
`105`		`- const auto& GraphicsPipeline = pPipelineStateGLImpl->GetGraphicsPipelineDesc();`
	`105`	`+ const auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();`
`106`	`106`	`// Set rasterizer state`
`107`	`107`	`{`
`108`	`108`	`const auto& RasterizerDesc = GraphicsPipeline.RasterizerDesc;`
Original file line number	Diff line number	Diff line change
`@@ -303,18 +303,18 @@ void DeviceContextVkImpl::SetPipelineState(IPipelineState* pPipelineState)`
`303`	`303`	`CommitScissor = !m_pPipelineState->GetGraphicsPipelineDesc().RasterizerDesc.ScissorEnable;`
`304`	`304`	`}`
`305`	`305`
`306`		`- TDeviceContextBase::SetPipelineState(pPipelineStateVk, 0 /Dummy/);`
	`306`	`+ TDeviceContextBase::SetPipelineState(std::move(pPipelineStateVk), 0 /Dummy/);`
`307`	`307`	`EnsureVkCmdBuffer();`
`308`	`308`
`309`		`- auto vkPipeline = pPipelineStateVk->GetVkPipeline();`
	`309`	`+ auto vkPipeline = m_pPipelineState->GetVkPipeline();`
`310`	`310`
`311`	`311`	`static_assert(PIPELINE_TYPE_LAST == 4, "Please update the switch below to handle the new pipeline type");`
`312`	`312`	`switch (PSODesc.PipelineType)`
`313`	`313`	`{`
`314`	`314`	`case PIPELINE_TYPE_GRAPHICS:`
`315`	`315`	`case PIPELINE_TYPE_MESH:`
`316`	`316`	`{`
`317`		`- auto& GraphicsPipeline = pPipelineStateVk->GetGraphicsPipelineDesc();`
	`317`	`+ auto& GraphicsPipeline = m_pPipelineState->GetGraphicsPipelineDesc();`
`318`	`318`	`m_CommandBuffer.BindGraphicsPipeline(vkPipeline);`
`319`	`319`
`320`	`320`	`if (CommitStates)`
`@@ -350,8 +350,8 @@ void DeviceContextVkImpl::SetPipelineState(IPipelineState* pPipelineState)`
`350`	`350`	`UNEXPECTED("unknown pipeline type");`
`351`	`351`	`}`
`352`	`352`
`353`		`- const auto& Layout = pPipelineStateVk->GetPipelineLayout();`
`354`		`- const auto SignCount = pPipelineStateVk->GetResourceSignatureCount();`
	`353`	`+ const auto& Layout = m_pPipelineState->GetPipelineLayout();`
	`354`	`+ const auto SignCount = m_pPipelineState->GetResourceSignatureCount();`
`355`	`355`	`auto& BindInfo = GetBindInfo(PSODesc.PipelineType);`
`356`	`356`
`357`	`357`	`Uint32 DvpCompatibleSRBCount = 0;`
`@@ -371,7 +371,7 @@ void DeviceContextVkImpl::SetPipelineState(IPipelineState* pPipelineState)`
`371`	`371`	`{`
`372`	`372`	`auto& SetInfo = BindInfo.SetInfo[i];`
`373`	`373`
`374`		`- auto* pSignature = pPipelineStateVk->GetResourceSignature(i);`
	`374`	`+ auto* pSignature = m_pPipelineState->GetResourceSignature(i);`
`375`	`375`	`if (pSignature == nullptr \|\| pSignature->GetNumDescriptorSets() == 0)`
`376`	`376`	`{`
`377`	`377`	`SetInfo = {};`