[d3d11,util] Add GPU execution cost heuristic for submissions

May fix GPU time-outs on tilers.

Author: doitsujin

src/d3d11/d3d11_cmdlist.cpp

@@ -54,8 +54,8 @@ namespace dxvk {
   }
 
 
-  uint64_t D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk) {
-    m_chunks.push_back(std::move(Chunk));
+  uint64_t D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk, uint64_t Cost) {
+    m_chunks.emplace_back(std::move(Chunk), Cost);
     return m_chunks.size() - 1;
   }
 
@@ -99,7 +99,7 @@ namespace dxvk {
         flushType = GpuFlushType::ImplicitStrongHint;
 
       // Dispatch the chunk and capture its sequence number
-      uint64_t seq = DispatchProc(DxvkCsChunkRef(m_chunks[i]), flushType);
+      uint64_t seq = DispatchProc(DxvkCsChunkRef(m_chunks[i].chunk), m_chunks[i].cost, flushType);
 
       // Track resource sequence numbers for the added chunk
       while (j < m_resources.size() && m_resources[j].chunkId == i)

src/d3d11/d3d11_cmdlist.h

@@ -6,7 +6,7 @@
 
 namespace dxvk {
 
-  using D3D11ChunkDispatchProc = std::function<uint64_t (DxvkCsChunkRef&&, GpuFlushType)>;
+  using D3D11ChunkDispatchProc = std::function<uint64_t (DxvkCsChunkRef&&, uint64_t, GpuFlushType)>;
 
   class D3D11CommandList : public D3D11DeviceChild<ID3D11CommandList> {
 
@@ -28,7 +28,8 @@ namespace dxvk {
             D3D11Query*         pQuery);
 
     uint64_t AddChunk(
-            DxvkCsChunkRef&&    Chunk);
+            DxvkCsChunkRef&&    Chunk,
+            uint64_t            Cost);
 
     uint64_t AddCommandList(
             D3D11CommandList*   pCommandList);
@@ -44,14 +45,22 @@ namespace dxvk {
 
   private:
 
+    struct ChunkEntry {
+      ChunkEntry() = default;
+      ChunkEntry(DxvkCsChunkRef&& c, uint64_t v)
+      : chunk(std::move(c)), cost(v) { }
+      DxvkCsChunkRef chunk = { };
+      uint64_t cost = 0u;
+    };
+
     struct TrackedResource {
       D3D11ResourceRef  ref;
       uint64_t          chunkId;
     };
 
     UINT m_contextFlags = 0u;
 
-    std::vector<DxvkCsChunkRef>         m_chunks;
+    std::vector<ChunkEntry>             m_chunks;
     std::vector<Com<D3D11Query, false>> m_queries;
     std::vector<TrackedResource>        m_resources;
 

src/d3d11/d3d11_context.cpp

@@ -395,6 +395,8 @@ namespace dxvk {
     if (counterView == nullptr)
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     EmitCs([
       cDstSlice = buf->GetBufferSlice(DstAlignedByteOffset),
       cSrcSlice = DxvkBufferSlice(counterView)
@@ -423,6 +425,8 @@ namespace dxvk {
     if (!rtv)
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     auto view  = rtv->GetImageView();
     auto color = ConvertColorValue(ColorRGBA, view->formatInfo());
 
@@ -451,6 +455,8 @@ namespace dxvk {
     if (FAILED(pUnorderedAccessView->QueryInterface(IID_PPV_ARGS(&qiUav))))
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     auto uav = static_cast<D3D11UnorderedAccessView*>(qiUav.ptr());
 
     // Gather UAV format info. We'll use this to determine
@@ -598,6 +604,8 @@ namespace dxvk {
     if (!info || info->flags.any(DxvkFormatFlag::SampledSInt, DxvkFormatFlag::SampledUInt))
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     VkClearValue clearValue;
     clearValue.color.float32[0] = Values[0];
     clearValue.color.float32[1] = Values[1];
@@ -657,6 +665,8 @@ namespace dxvk {
     if (!aspectMask)
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     VkClearValue clearValue;
     clearValue.depthStencil.depth   = Depth;
     clearValue.depthStencil.stencil = Stencil;
@@ -683,6 +693,8 @@ namespace dxvk {
     if (NumRects && !pRect)
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     // ID3D11View has no methods to query the exact type of
     // the view, so we'll have to check each possible class
     auto dsv = dynamic_cast<D3D11DepthStencilView*>(pView);
@@ -768,6 +780,8 @@ namespace dxvk {
     if (!(resourceDesc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS))
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     EmitCs([cDstImageView = view->GetImageView()]
     (DxvkContext* ctx) {
       ctx->generateMipmaps(cDstImageView, VK_FILTER_LINEAR);
@@ -825,6 +839,8 @@ namespace dxvk {
      || SrcSubresource >= srcTextureInfo->CountSubresources())
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     const VkImageSubresource dstSubresource =
       dstTextureInfo->GetSubresourceFromIndex(
         dstVulkanFormatInfo->aspectMask, DstSubresource);
@@ -1148,6 +1164,8 @@ namespace dxvk {
     if (unlikely(!ThreadGroupCountX || !ThreadGroupCountY || !ThreadGroupCountZ))
       return;
 
+    AddCost(GpuCostEstimate::Dispatch);
+
     if (unlikely(HasDirtyComputeBindings()))
       ApplyDirtyComputeBindings();
 
@@ -1170,6 +1188,8 @@ namespace dxvk {
     if (!ValidateDrawBufferSize(pBufferForArgs, AlignedByteOffsetForArgs, sizeof(VkDispatchIndirectCommand)))
       return;
 
+    AddCost(GpuCostEstimate::DispatchIndirect);
+
     if (unlikely(HasDirtyComputeBindings()))
       ApplyDirtyComputeBindings();
 
@@ -4151,6 +4171,8 @@ namespace dxvk {
     if (SrcOffset >= srcLength || DstOffset >= dstLength || !ByteCount)
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     ByteCount = std::min(dstLength - DstOffset, ByteCount);
     ByteCount = std::min(srcLength - SrcOffset, ByteCount);
 
@@ -4234,6 +4256,8 @@ namespace dxvk {
     if (!SrcExtent.width || !SrcExtent.height || !SrcExtent.depth)
       return;
 
+    AddCost(GpuCostEstimate::Transfer);
+
     // While copying between 2D and 3D images is allowed in CopySubresourceRegion,
     // copying more than one slice at a time is not suppoted. Layer counts are 1.
     if ((pDstTexture->GetVkImageType() == VK_IMAGE_TYPE_3D)
@@ -4461,6 +4485,8 @@ namespace dxvk {
       tiles[i] = tile;
     }
 
+    AddCost(GpuCostEstimate::Transfer);
+
     // If D3D12 is anything to go by, not passing this flag will trigger
     // the other code path, regardless of whether TO_LINEAR_BUFFER is set.
     if (Flags & D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE) {
@@ -5372,6 +5398,7 @@ namespace dxvk {
     }
 
     if (needsUpdate) {
+      AddCost(GpuCostEstimate::RenderPass);
       BindFramebuffer();
 
       if constexpr (!IsDeferred)

src/d3d11/d3d11_context.h

@@ -79,7 +79,6 @@ namespace dxvk {
   protected:
     // Compile-time debug flag to force lazy binding on (True) or off (False)
     constexpr static Tristate DebugLazyBinding = Tristate::Auto;
-
   public:
 
     D3D11CommonContext(
@@ -799,6 +798,8 @@ namespace dxvk {
     DxvkCsChunkRef              m_csChunk;
     DxvkCsDataBlock*            m_csData = nullptr;
 
+    uint64_t                    m_estimatedCost = 0u;
+
     DxvkLocalAllocationCache    m_allocationCache;
 
     D3D11ShaderStageState<Rc<DxvkBuffer>> m_instanceData;
@@ -1181,6 +1182,10 @@ namespace dxvk {
     Rc<DxvkBuffer> AllocInstanceDataBuffer(
             D3D11ShaderType                   ShaderStage);
 
+    force_inline void AddCost(uint64_t Value) {
+      m_estimatedCost += Value;
+    }
+
     static DxvkInputAssemblyState InitDefaultPrimitiveTopology();
 
     static DxvkRasterizerState InitDefaultRasterizerState();

src/d3d11/d3d11_context_def.cpp

@@ -397,7 +397,8 @@ namespace dxvk {
 
 
   void D3D11DeferredContext::EmitCsChunk(DxvkCsChunkRef&& chunk) {
-    m_chunkId = m_commandList->AddChunk(std::move(chunk));
+    m_chunkId = m_commandList->AddChunk(std::move(chunk), m_estimatedCost);
+    m_estimatedCost = 0u;
   }
 
 

src/d3d11/d3d11_context_ext.cpp

@@ -46,6 +46,7 @@ namespace dxvk {
           UINT                    ByteOffsetForArgs,
           UINT                    ByteStrideForArgs) {
     D3D10DeviceLock lock = m_ctx->LockContext();
+    m_ctx->AddCost(GpuCostEstimate::DrawIndirect);
     m_ctx->SetDrawBuffers(pBufferForArgs, nullptr);
 
     if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
@@ -68,8 +69,9 @@ namespace dxvk {
           UINT                    ByteOffsetForArgs,
           UINT                    ByteStrideForArgs) {
     D3D10DeviceLock lock = m_ctx->LockContext();
+    m_ctx->AddCost(GpuCostEstimate::DrawIndirect);
     m_ctx->SetDrawBuffers(pBufferForArgs, nullptr);
-    
+
     if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
       m_ctx->ApplyDirtyGraphicsBindings();
 
@@ -92,6 +94,7 @@ namespace dxvk {
           UINT                    ByteOffsetForArgs,
           UINT                    ByteStrideForArgs) {
     D3D10DeviceLock lock = m_ctx->LockContext();
+    m_ctx->AddCost(GpuCostEstimate::DrawIndirect);
     m_ctx->SetDrawBuffers(pBufferForArgs, pBufferForCount);
 
     if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
@@ -117,6 +120,7 @@ namespace dxvk {
           UINT                    ByteOffsetForArgs,
           UINT                    ByteStrideForArgs) {
     D3D10DeviceLock lock = m_ctx->LockContext();
+    m_ctx->AddCost(GpuCostEstimate::DrawIndirect);
     m_ctx->SetDrawBuffers(pBufferForArgs, pBufferForCount);
 
     if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
@@ -212,6 +216,8 @@ namespace dxvk {
     launchInfo.shader = cubinShader;
 
     /* Need to capture by value in case this gets called from a deferred context */
+    m_ctx->AddCost(GpuCostEstimate::Dispatch);
+
     m_ctx->EmitCs([cLaunchInfo = std::move(launchInfo)] (DxvkContext* ctx) {
       ctx->launchCuKernelNVX(cLaunchInfo.nvxLaunchInfo, cLaunchInfo.buffers, cLaunchInfo.images);
     });

src/d3d11/d3d11_context_imm.cpp

@@ -261,7 +261,7 @@ namespace dxvk {
     ConsiderFlush(GpuFlushType::ImplicitWeakHint);
 
     // Dispatch command list to the CS thread
-    commandList->EmitToCsThread([this] (DxvkCsChunkRef&& chunk, GpuFlushType flushType) {
+    commandList->EmitToCsThread([this] (DxvkCsChunkRef&& chunk, uint64_t cost, GpuFlushType flushType) {
       EmitCsChunk(std::move(chunk));
 
       // Return the sequence number from before the flush since
@@ -270,6 +270,7 @@ namespace dxvk {
 
       // Consider a flush after every chunk in case the app
       // submits a very large command list or the GPU is idle
+      AddCost(cost);
       ConsiderFlush(flushType);
       return csSeqNum;
     });
@@ -1110,7 +1111,7 @@ namespace dxvk {
     uint64_t chunkId = GetCurrentSequenceNumber();
     uint64_t submissionId = m_submissionFence->value();
 
-    if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId))
+    if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId, m_estimatedCost))
       ExecuteFlush(FlushType, nullptr, false);
   }
 
@@ -1173,6 +1174,9 @@ namespace dxvk {
     // Reset counter for discarded memory in flight
     m_discardMemoryOnFlush = m_discardMemoryCounter;
 
+    // Reset GPU execution cost estimate
+    m_estimatedCost = 0u;
+
     // Notify the device that the context has been flushed,
     // this resets some resource initialization heuristics.
     m_parent->NotifyContextFlush();

src/d3d9/d3d9_device.cpp

@@ -5876,7 +5876,7 @@ namespace dxvk {
     uint64_t chunkId = GetCurrentSequenceNumber();
     uint64_t submissionId = m_submissionFence->value();
 
-    if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId))
+    if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId, 0u))
       Flush();
   }
 

src/util/util_flush.cpp

@@ -1,4 +1,6 @@
 #include "util_flush.h"
+#include "util_string.h"
+#include "log/log.h"
 
 namespace dxvk {
 
@@ -10,7 +12,8 @@ namespace dxvk {
   bool GpuFlushTracker::considerFlush(
           GpuFlushType          flushType,
           uint64_t              chunkId,
-          uint32_t              lastCompleteSubmissionId) {
+          uint32_t              lastCompleteSubmissionId,
+          uint64_t              estimatedCost) {
     constexpr uint32_t minPendingSubmissions = 2;
 
     constexpr uint32_t minChunkCount =  3u;
@@ -22,8 +25,14 @@ namespace dxvk {
     if (!chunkCount)
       return false;
 
-    if (flushType > m_maxType)
-      return false;
+    // Deliberately ignore cost heuristic if we're not categorically ignoring
+    // submission requests anyway, since we should never submit enough to time
+    // out with the chunk-based heuristic.
+    if (flushType > m_maxType) {
+      if (estimatedCost >= GpuCostEstimate::MaxCostPerSubmission)
+        Logger::err("frog");
+      return estimatedCost >= GpuCostEstimate::MaxCostPerSubmission;
+    }
 
     // Take any earlier missed flush with a stronger hint into account, so
     // that we still flush those as soon as possible. Ignore synchronization

src/util/util_flush.h

@@ -6,6 +6,33 @@
 
 namespace dxvk {
 
+  /**
+   * \brief GPU cost estimate for various operations
+   *
+   * These provide only a very rough estimate for GPU execution times,
+   * which can be useful to avoid GPU time-outs in some situations.
+   */
+  struct GpuCostEstimate {
+    /** Assume that compute dispatches are much more expensive than draws
+     *  regardless of workgroup counts. This is not always true, but may
+     *  help account for immediate synchronization or complex shaders that
+     *  we do not generally have any up-front knowledge about. */
+    static constexpr uint64_t Dispatch              = 4u;
+    static constexpr uint64_t DispatchIndirect      = 5u;
+    /** Assume a high base cost per render pass. We're not counting draws
+     *  in order to avoid splitting passes on tiling GPUs, and draw costs
+     *  can vary wildly anyway. */
+    static constexpr uint64_t RenderPass            = 10u;
+    /** Transfer cost can vary wildly, but so do use cases. Just assume
+     *  a low cost, especially since synchronization on back-to-back
+     *  transfers is unlikely to be necessary. */
+    static constexpr uint64_t Transfer              = 2u;
+
+    /** Cost threshold at which submissions are always preferred */
+    static constexpr uint64_t MaxCostPerSubmission  = 1'500u;
+  };
+
+
   /**
    * \brief GPU context flush type
    */
@@ -60,12 +87,14 @@ namespace dxvk {
      * \param [in] flushType Flush type
      * \param [in] chunkId GPU command sequence number
      * \param [in] lastCompleteSubmissionId Last completed command submission ID
+     * \param [in] estimatedCost Estimated submission cost
      * \returns \c true if a flush should be performed
      */
     bool considerFlush(
             GpuFlushType          flushType,
             uint64_t              chunkId,
-            uint32_t              lastCompleteSubmissionId);
+            uint32_t              lastCompleteSubmissionId,
+            uint64_t              estimatedCost);
 
     /**
      * \brief Notifies tracker about a context flush