kc3-lang/angle/src/libANGLE/renderer/vulkan/ResourceVk.cpp

• Show log

  Commit

• Hash : 55840e90
  Author :
  Date : 2021-12-03T15:24:00
  

  Vulkan: Fix deferred flush vs UtilsVk
  
  Take the following scenario:
  
  1. Draw
  2. Flush (this is deferred)
  3. Get image view (this is retain()ed)
  4. Pass view to a draw-based UtilsVk function
  5. Flush
  6. Delete image view
  
  At step 4, UtilsVk may start a new render pass and use the image view
  from step 3.  Since the flush at step 2 is deferred, it will be
  performed at this step, and so the serial of the image view is set to
  the previous submission.
  
  When step 4 uses this view, it doesn't retain it.  Step 5 submits the
  new command buffer using this image view.
  
  At step 6, if the previous submission has finished, it will destroy the
  view immediately even though it's in use by the new submission.
  
  One solution could have been to make sure render pass closure
  originating from UtilsVk doesn't incur a flush.  However, due to the
  current design where the render pass is immediately recorded in
  RendererVk's primary command buffer, it's possible that an unrelated
  context would perform the flush anyway.
  
  This change makes sure instead that the render pass is closed before any
  views are allocated/retained to be used by UtilsVk.
  
  Bug: chromium:1272266
  Change-Id: I5bdefb34e03c368511c4c174cf7965fda158d2b8
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3315976
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/ResourceVk.cpp

• //
  // Copyright 2017 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.
  //
  // Resource:
  //    Resource lifetime tracking in the Vulkan back-end.
  //
  
  #include "libANGLE/renderer/vulkan/ResourceVk.h"
  
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  
  namespace rx
  {
  namespace vk
  {
  namespace
  {
  angle::Result FinishRunningCommands(ContextVk *contextVk, Serial serial)
  {
      return contextVk->finishToSerial(serial);
  }
  
  template <typename T>
  angle::Result WaitForIdle(ContextVk *contextVk,
                            T *resource,
                            const char *debugMessage,
                            RenderPassClosureReason reason)
  {
      // If there are pending commands for the resource, flush them.
      if (resource->usedInRecordedCommands())
      {
          ANGLE_TRY(contextVk->flushImpl(nullptr, reason));
      }
  
      // Make sure the driver is done with the resource.
      if (resource->usedInRunningCommands(contextVk->getLastCompletedQueueSerial()))
      {
          if (debugMessage)
          {
              ANGLE_VK_PERF_WARNING(contextVk, GL_DEBUG_SEVERITY_HIGH, "%s", debugMessage);
          }
          ANGLE_TRY(resource->finishRunningCommands(contextVk));
      }
  
      ASSERT(!resource->isCurrentlyInUse(contextVk->getLastCompletedQueueSerial()));
  
      return angle::Result::Continue;
  }
  }  // namespace
  
  // Resource implementation.
  Resource::Resource()
  {
      mUse.init();
  }
  
  Resource::Resource(Resource &&other) : Resource()
  {
      mUse = std::move(other.mUse);
  }
  
  Resource &Resource::operator=(Resource &&rhs)
  {
      std::swap(mUse, rhs.mUse);
      return *this;
  }
  
  Resource::~Resource()
  {
      mUse.release();
  }
  
  angle::Result Resource::finishRunningCommands(ContextVk *contextVk)
  {
      return FinishRunningCommands(contextVk, mUse.getSerial());
  }
  
  angle::Result Resource::waitForIdle(ContextVk *contextVk,
                                      const char *debugMessage,
                                      RenderPassClosureReason reason)
  {
      return WaitForIdle(contextVk, this, debugMessage, reason);
  }
  
  // Resource implementation.
  ReadWriteResource::ReadWriteResource()
  {
      mReadOnlyUse.init();
      mReadWriteUse.init();
  }
  
  ReadWriteResource::ReadWriteResource(ReadWriteResource &&other) : ReadWriteResource()
  {
      mReadOnlyUse  = std::move(other.mReadOnlyUse);
      mReadWriteUse = std::move(other.mReadWriteUse);
  }
  
  ReadWriteResource::~ReadWriteResource()
  {
      mReadOnlyUse.release();
      mReadWriteUse.release();
  }
  
  angle::Result ReadWriteResource::finishRunningCommands(ContextVk *contextVk)
  {
      ASSERT(!mReadOnlyUse.usedInRecordedCommands());
      return FinishRunningCommands(contextVk, mReadOnlyUse.getSerial());
  }
  
  angle::Result ReadWriteResource::finishGPUWriteCommands(ContextVk *contextVk)
  {
      ASSERT(!mReadWriteUse.usedInRecordedCommands());
      return FinishRunningCommands(contextVk, mReadWriteUse.getSerial());
  }
  
  angle::Result ReadWriteResource::waitForIdle(ContextVk *contextVk,
                                               const char *debugMessage,
                                               RenderPassClosureReason reason)
  {
      return WaitForIdle(contextVk, this, debugMessage, reason);
  }
  
  // SharedGarbage implementation.
  SharedGarbage::SharedGarbage() = default;
  
  SharedGarbage::SharedGarbage(SharedGarbage &&other)
  {
      *this = std::move(other);
  }
  
  SharedGarbage::SharedGarbage(SharedResourceUse &&use, std::vector<GarbageObject> &&garbage)
      : mLifetime(std::move(use)), mGarbage(std::move(garbage))
  {}
  
  SharedGarbage::~SharedGarbage() = default;
  
  SharedGarbage &SharedGarbage::operator=(SharedGarbage &&rhs)
  {
      std::swap(mLifetime, rhs.mLifetime);
      std::swap(mGarbage, rhs.mGarbage);
      return *this;
  }
  
  bool SharedGarbage::destroyIfComplete(RendererVk *renderer, Serial completedSerial)
  {
      if (mLifetime.isCurrentlyInUse(completedSerial))
      {
          return false;
      }
  
      for (GarbageObject &object : mGarbage)
      {
          object.destroy(renderer);
      }
  
      mLifetime.release();
  
      return true;
  }
  
  // ResourceUseList implementation.
  ResourceUseList::ResourceUseList()
  {
      constexpr size_t kDefaultResourceUseCount = 4096;
      mResourceUses.reserve(kDefaultResourceUseCount);
  }
  
  ResourceUseList::ResourceUseList(ResourceUseList &&other)
  {
      *this = std::move(other);
  }
  
  ResourceUseList::~ResourceUseList()
  {
      ASSERT(mResourceUses.empty());
  }
  
  ResourceUseList &ResourceUseList::operator=(ResourceUseList &&rhs)
  {
      std::swap(mResourceUses, rhs.mResourceUses);
      return *this;
  }
  
  void ResourceUseList::releaseResourceUses()
  {
      for (SharedResourceUse &use : mResourceUses)
      {
          use.release();
      }
  
      mResourceUses.clear();
  }
  
  void ResourceUseList::releaseResourceUsesAndUpdateSerials(Serial serial)
  {
      for (SharedResourceUse &use : mResourceUses)
      {
          use.releaseAndUpdateSerial(serial);
      }
  
      mResourceUses.clear();
  }
  }  // namespace vk
  }  // namespace rx
  

Download