kc3-lang/angle/src/libANGLE/renderer/metal/mtl_occlusion_query_pool.mm

• Show log

  Commit

• Hash : a0126d55
  Author :
  Date : 2024-09-06T11:58:58
  

  Metal: Clear mRenderPassesSinceFlush to avoid infinite recursion
  
  When there is more than kMaxRenderPassesPerCommandBuffer render passes
  with active occlusion query, it's possible for the Metal backend to end
  up in infinite recursion of the following call sequence:
  
  `ensureCommandBufferReady` -> `flushCommandBufferIfNeeded` ->
  `flushCommandBuffer` -> `endEncoding` -> `endRenderEncoding` ->
  `prepareRenderPassVisibilityPoolBuffer` ->
  `getBlitCommandEncoderWithoutEndingRenderEncoder` ->
  `ensureCommandBufferReady`
  
  This recursion is caused by the checks in flushCommandBufferIfNeeded not
  being disarmed once the flush has started and is most likely caused by
  |mRenderPassesSinceFlush| exceeding |kMaxRenderPassesPerCommandBuffer|.
  
  This change moves the clearing of |mRenderPassesSinceFlush| to the top
  of of `flushCommandBuffer`, before any calls to `endEncoding`, breaking
  the need to call `flushCommandBuffer` via
  `getBlitCommandEncoderWithoutEndingRenderEncoder`.
  
  Additionally, |OcclusionQueryPool::mUsed| is set to false before the
  results are cleared. This will also break the recursion and is added for
  the `mCmdBuffer.needsFlushForDrawCallLimits` case in
  `flushCommandBufferIfNeeded`.
  
  Change-Id: Ib54c0a87ae9c5365ae56d487b6bef99b681d9f59
  Fixed: chromium:362791944
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5839224
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  Commit-Queue: Kenneth Russell <kbr@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/metal/mtl_occlusion_query_pool.mm

• //
  // Copyright (c) 2020 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // mtl_occlusion_query_pool: A visibility pool for allocating visibility query within
  // one render pass.
  //
  
  #include "libANGLE/renderer/metal/mtl_occlusion_query_pool.h"
  
  #include "libANGLE/renderer/metal/ContextMtl.h"
  #include "libANGLE/renderer/metal/DisplayMtl.h"
  #include "libANGLE/renderer/metal/QueryMtl.h"
  
  namespace rx
  {
  namespace mtl
  {
  
  // OcclusionQueryPool implementation
  OcclusionQueryPool::OcclusionQueryPool() {}
  OcclusionQueryPool::~OcclusionQueryPool() {}
  
  void OcclusionQueryPool::destroy(ContextMtl *contextMtl)
  {
      mRenderPassResultsPool = nullptr;
      for (QueryMtl *allocatedQuery : mAllocatedQueries)
      {
          if (!allocatedQuery)
          {
              continue;
          }
          allocatedQuery->clearAllocatedVisibilityOffsets();
      }
      mAllocatedQueries.clear();
  }
  
  angle::Result OcclusionQueryPool::allocateQueryOffset(ContextMtl *contextMtl,
                                                        QueryMtl *query,
                                                        bool clearOldValue)
  {
      // Only query that already has allocated offset or first query of the render pass is allowed to
      // keep old value. Other queries must be reset to zero before counting the samples visibility in
      // draw calls.
      ASSERT(clearOldValue || mAllocatedQueries.empty() ||
             !query->getAllocatedVisibilityOffsets().empty());
  
      uint32_t currentOffset =
          static_cast<uint32_t>(mAllocatedQueries.size()) * kOcclusionQueryResultSize;
      if (!mRenderPassResultsPool)
      {
          ASSERT(!mUsed);
          // First allocation
          ANGLE_TRY(Buffer::MakeBufferWithStorageMode(contextMtl, MTLStorageModePrivate,
                                                      kOcclusionQueryResultSize, nullptr,
                                                      &mRenderPassResultsPool));
          mRenderPassResultsPool->get().label = @"OcclusionQueryPool";
      }
      else if (currentOffset + kOcclusionQueryResultSize > mRenderPassResultsPool->size())
      {
          // Double the capacity
          ANGLE_TRY(Buffer::MakeBufferWithStorageMode(contextMtl, MTLStorageModePrivate,
                                                      mRenderPassResultsPool->size() * 2, nullptr,
                                                      &mRenderPassResultsPool));
          mUsed                               = false;
          mRenderPassResultsPool->get().label = @"OcclusionQueryPool";
      }
  
      if (clearOldValue)
      {
          // If old value is not needed, deallocate any offset previously allocated for this query.
          deallocateQueryOffset(contextMtl, query);
      }
      if (query->getAllocatedVisibilityOffsets().empty())
      {
          mAllocatedQueries.push_back(query);
          query->setFirstAllocatedVisibilityOffset(currentOffset);
      }
      else
      {
          // Additional offset allocated for a query is only allowed if it is a continuous region.
          ASSERT(currentOffset ==
                 query->getAllocatedVisibilityOffsets().back() + kOcclusionQueryResultSize);
          // Just reserve an empty slot in the allocated query array
          mAllocatedQueries.push_back(nullptr);
          query->addAllocatedVisibilityOffset();
      }
  
      if (currentOffset == 0)
      {
          mResetFirstQuery = clearOldValue;
          if (!clearOldValue && !contextMtl->getDisplay()->getFeatures().allowBufferReadWrite.enabled)
          {
              // If old value of first query needs to be retained and device doesn't support buffer
              // read-write, we need an additional offset to store the old value of the query.
              return allocateQueryOffset(contextMtl, query, false);
          }
      }
  
      return angle::Result::Continue;
  }
  
  void OcclusionQueryPool::deallocateQueryOffset(ContextMtl *contextMtl, QueryMtl *query)
  {
      if (query->getAllocatedVisibilityOffsets().empty())
      {
          return;
      }
  
      mAllocatedQueries[query->getAllocatedVisibilityOffsets().front() / kOcclusionQueryResultSize] =
          nullptr;
      query->clearAllocatedVisibilityOffsets();
  }
  
  void OcclusionQueryPool::resolveVisibilityResults(ContextMtl *contextMtl)
  {
      if (mAllocatedQueries.empty())
      {
          return;
      }
  
      RenderUtils &utils              = contextMtl->getDisplay()->getUtils();
      BlitCommandEncoder *blitEncoder = nullptr;
      // Combine the values stored in the offsets allocated for first query
      if (mAllocatedQueries[0])
      {
          const BufferRef &dstBuf = mAllocatedQueries[0]->getVisibilityResultBuffer();
          const VisibilityBufferOffsetsMtl &allocatedOffsets =
              mAllocatedQueries[0]->getAllocatedVisibilityOffsets();
          if (!mResetFirstQuery &&
              !contextMtl->getDisplay()->getFeatures().allowBufferReadWrite.enabled)
          {
              // If we cannot read and write to the same buffer in shader. We need to copy the old
              // value of first query to first offset allocated for it.
              blitEncoder = contextMtl->getBlitCommandEncoder();
              blitEncoder->copyBuffer(dstBuf, 0, mRenderPassResultsPool, allocatedOffsets.front(),
                                      kOcclusionQueryResultSize);
              utils.combineVisibilityResult(contextMtl, false, allocatedOffsets,
                                            mRenderPassResultsPool, dstBuf);
          }
          else
          {
              utils.combineVisibilityResult(contextMtl, !mResetFirstQuery, allocatedOffsets,
                                            mRenderPassResultsPool, dstBuf);
          }
      }
  
      // Combine the values stored in the offsets allocated for each of the remaining queries
      for (size_t i = 1; i < mAllocatedQueries.size(); ++i)
      {
          QueryMtl *query = mAllocatedQueries[i];
          if (!query)
          {
              continue;
          }
  
          const BufferRef &dstBuf = mAllocatedQueries[i]->getVisibilityResultBuffer();
          const VisibilityBufferOffsetsMtl &allocatedOffsets =
              mAllocatedQueries[i]->getAllocatedVisibilityOffsets();
          utils.combineVisibilityResult(contextMtl, false, allocatedOffsets, mRenderPassResultsPool,
                                        dstBuf);
      }
  
      // Request synchronization and cleanup
      blitEncoder = contextMtl->getBlitCommandEncoder();
      for (size_t i = 0; i < mAllocatedQueries.size(); ++i)
      {
          QueryMtl *query = mAllocatedQueries[i];
          if (!query)
          {
              continue;
          }
  
          const BufferRef &dstBuf = mAllocatedQueries[i]->getVisibilityResultBuffer();
  
          dstBuf->syncContent(contextMtl, blitEncoder);
  
          query->clearAllocatedVisibilityOffsets();
      }
  
      mAllocatedQueries.clear();
  }
  
  void OcclusionQueryPool::prepareRenderPassVisibilityPoolBuffer(ContextMtl *contextMtl)
  {
      if (mAllocatedQueries.empty())
      {
          return;
      }
  
      // If the current visibility pool buffer was not used before,
      // ensure that it will be cleared next time.
      if (!mUsed)
      {
          mUsed = true;
          return;
      }
  
      mUsed = false;
  
      // If the current visibility pool buffer was used before,
      // ensure that it does not contain previous results.
      auto blitEncoder = contextMtl->getBlitCommandEncoderWithoutEndingRenderEncoder();
      blitEncoder->fillBuffer(mRenderPassResultsPool,
                              NSMakeRange(0, mAllocatedQueries.size() * kOcclusionQueryResultSize),
                              0);
      blitEncoder->endEncoding();
  }
  
  }  // namespace mtl
  }  // namespace rx
  

Download