Scope: Added feature to wait a fence to be triggered (o3de#17569)

* Optionally use timeline semaphores for Vulkan Fences
* Scope: Added fences to wait for

Signed-off-by: Martin Sattlecker <[email protected]>
Co-authored-by: Martin Winter <[email protected]>

Author: msat-huawei

Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceFeatures.h

@@ -96,6 +96,10 @@ namespace AZ::RHI
         //! Whether swapchain scaling support is available.
         RHI::ScalingFlags m_swapchainScalingFlags = RHI::ScalingFlags::None;
 
+        //! Whether fences can be signalled from the CPU
+        //! If this is false, the Fence::SignalOnCpu inserts the signal command into a queue
+        bool m_signalFenceFromCPU = false;
+
         /// Additional features here.
     };
 }

Gems/Atom/RHI/Code/Include/Atom/RHI/FrameGraph.h

@@ -110,6 +110,7 @@ namespace AZ::RHI
         void ExecuteAfter(const ScopeId& scopeId);
         void ExecuteBefore(const ScopeId& scopeId);
         void SignalFence(Fence& fence);
+        void WaitFence(Fence& fence);
         void SetEstimatedItemCount(uint32_t itemCount);
         void SetHardwareQueueClass(HardwareQueueClass hardwareQueueClass);
 

Gems/Atom/RHI/Code/Include/Atom/RHI/FrameGraphInterface.h

@@ -208,7 +208,13 @@ namespace AZ::RHI
         {
             m_frameGraph.SignalFence(fence);
         }
-            
+
+        //! Requests that the provided fence be waited for before the scope has started.
+        void WaitFence(Fence& fence)
+        {
+            m_frameGraph.WaitFence(fence);
+        }
+
         //! Sets the number of work items (Draw / Dispatch / etc) that will be processed by
         //! this scope. This value is used to load-balance the scope across command lists. A small
         //! value may result in the scope being merged onto a single command list, whereas a large

Gems/Atom/RHI/Code/Include/Atom/RHI/Scope.h

@@ -117,6 +117,9 @@ namespace AZ::RHI
         //! Returns a list of fences to signal on completion of the scope.
         const AZStd::vector<Ptr<Fence>>& GetFencesToSignal() const;
 
+        //! Returns a list of fences to wait for before start of the scope.
+        const AZStd::vector<Ptr<Fence>>& GetFencesToWaitFor() const;
+
         //! Initializes the scope.
         void Init(const ScopeId& scopeId, HardwareQueueClass hardwareQueueClass = HardwareQueueClass::Graphics);
 
@@ -240,6 +243,9 @@ namespace AZ::RHI
         /// The set of fences to signal on scope completion.
         AZStd::vector<Ptr<Fence>>                m_fencesToSignal;
 
+        /// The set of fences to wait for before scope has started.
+        AZStd::vector<Ptr<Fence>> m_fencesToWaitFor;
+
         /// The set query pools.
         AZStd::vector<Ptr<QueryPool>>                m_queryPools;
     };

Gems/Atom/RHI/Code/Source/RHI/FrameGraph.cpp

@@ -429,6 +429,11 @@ namespace AZ::RHI
         m_currentScope->m_fencesToSignal.push_back(&fence);
     }
 
+    void FrameGraph::WaitFence(Fence& fence)
+    {
+        m_currentScope->m_fencesToWaitFor.push_back(&fence);
+    }
+
     ResultCode FrameGraph::TopologicalSort()
     {
         struct NodeId

Gems/Atom/RHI/Code/Source/RHI/Scope.cpp

@@ -91,6 +91,7 @@ namespace AZ::RHI
         m_bufferAttachments.clear();
         m_swapChainsToPresent.clear();
         m_fencesToSignal.clear();
+        m_fencesToWaitFor.clear();
         m_resourcePoolResolves.clear();
         m_queryPools.clear();
     }
@@ -222,6 +223,11 @@ namespace AZ::RHI
         return m_fencesToSignal;
     }
 
+    const AZStd::vector<Ptr<Fence>>& Scope::GetFencesToWaitFor() const
+    {
+        return m_fencesToWaitFor;
+    }
+
     Scope* Scope::GetProducerByQueue(HardwareQueueClass hardwareQueueClass) const
     {
         return m_producersByQueue[static_cast<size_t>(hardwareQueueClass)];

Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueue.cpp

@@ -144,6 +144,11 @@ namespace AZ
                 static const uint32_t CommandListCountMax = 128;
                 ID3D12CommandQueue* dx12CommandQueue = static_cast<ID3D12CommandQueue*>(commandQueue);
 
+                for (Fence* fence : request.m_userFencesToWaitFor)
+                {
+                    dx12CommandQueue->Wait(fence->Get(), fence->GetPendingValue());
+                }
+
                 for (size_t producerQueueIdx = 0; producerQueueIdx < request.m_waitFences.size(); ++producerQueueIdx)
                 {
                     if (const uint64_t fenceValue = request.m_waitFences[producerQueueIdx])

Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueue.h

@@ -34,6 +34,9 @@ namespace AZ
 
             /// A set of user fences to signal after executing the command lists.
             AZStd::vector<Fence*> m_userFencesToSignal;
+
+            /// A set of user fences to wait for before executing the command lists.
+            AZStd::vector<Fence*> m_userFencesToWaitFor;
         };
 
         enum class HardwareQueueSubclass

Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp

@@ -298,6 +298,8 @@ namespace AZ
                     RHI::ShadingRateFlags::Rate4x4;
             }
 
+            m_features.m_signalFenceFromCPU = true;
+
             m_limits.m_shadingRateTileSize = RHI::Size(options6.ShadingRateImageTileSize, options6.ShadingRateImageTileSize, 1);
 #endif
 

Gems/Atom/RHI/DX12/Code/Source/RHI/FrameGraphExecuteGroupMerged.cpp

@@ -54,6 +54,16 @@ namespace AZ
                         fencesToSignal.push_back(&static_cast<FenceImpl&>(*fence).Get());
                     }
                 }
+
+                {
+                    auto& fencesToWaitFor = m_workRequest.m_userFencesToWaitFor;
+
+                    fencesToWaitFor.reserve(fencesToWaitFor.size() + scope->GetFencesToWaitFor().size());
+                    for (const RHI::Ptr<RHI::Fence>& fence : scope->GetFencesToWaitFor())
+                    {
+                        fencesToWaitFor.push_back(&static_cast<FenceImpl&>(*fence).Get());
+                    }
+                }
             }
 
             InitMergedRequest request;