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

Branch - branch -main

• Show log

  Commit

• Hash : 25390156
  Author :
  Date : 2025-08-21T00:13:19
  

  Suppress unsafe buffers on a file-by-file basis in src/ [1 of N]
  
  In this CL, we suppress many files but stop short of actually
  enabling the warning by not removing the line from the
  unsafe_buffers_paths.txt file. That will happen in a follow-on
  CL, along with resolving any stragglers missed here.
  
  This is mostly a manual change so as to familiarize myself with
  the kinds of issues faced by the Angle codebase when applying buffer
  safety warnings.
  
  -- Re-generate affected hashes.
  -- Clang-format applied to all changed files.
  -- Add a few missing .reserve() calls to vectors as noticed.
  -- Fix some mismatches between file names and header comments.
  -- Be more consistent with header comment format (blank lines and
     trailing //-only lines when a filename comment adjoins license
     boilerplate).
  
  Bug: b/436880895
  Change-Id: I3bde5cc2059acbe8345057289214f1a26f1c34aa
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6869022
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/vk_resource.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.
  //
  
  #ifdef UNSAFE_BUFFERS_BUILD
  #    pragma allow_unsafe_libc_calls
  #endif
  
  #include "libANGLE/renderer/vulkan/vk_resource.h"
  
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  
  namespace rx
  {
  namespace vk
  {
  // Resource implementation.
  angle::Result Resource::waitForIdle(ContextVk *contextVk,
                                      const char *debugMessage,
                                      RenderPassClosureReason reason)
  {
      // If there are pending commands for the resource, flush them.
      if (contextVk->hasUnsubmittedUse(mUse))
      {
          ANGLE_TRY(contextVk->flushAndSubmitCommands(nullptr, nullptr, reason));
      }
  
      Renderer *renderer = contextVk->getRenderer();
      // Make sure the driver is done with the resource.
      if (!renderer->hasResourceUseFinished(mUse))
      {
          if (debugMessage)
          {
              ANGLE_VK_PERF_WARNING(contextVk, GL_DEBUG_SEVERITY_HIGH, "%s", debugMessage);
          }
          ANGLE_TRY(renderer->finishResourceUse(contextVk, mUse));
      }
  
      ASSERT(renderer->hasResourceUseFinished(mUse));
  
      return angle::Result::Continue;
  }
  
  std::ostream &operator<<(std::ostream &os, const ResourceUse &use)
  {
      const Serials &serials = use.getSerials();
      os << '{';
      for (size_t i = 0; i < serials.size(); i++)
      {
          os << serials[i].getValue();
          if (i < serials.size() - 1)
          {
              os << ",";
          }
      }
      os << '}';
      return os;
  }
  
  // SharedGarbage implementation.
  SharedGarbage::SharedGarbage() = default;
  
  SharedGarbage::SharedGarbage(SharedGarbage &&other)
  {
      *this = std::move(other);
  }
  
  SharedGarbage::SharedGarbage(const ResourceUse &use, GarbageObjects &&garbage)
      : mLifetime(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(Renderer *renderer)
  {
      if (renderer->hasResourceUseFinished(mLifetime))
      {
          for (GarbageObject &object : mGarbage)
          {
              object.destroy(renderer);
          }
          return true;
      }
      return false;
  }
  
  bool SharedGarbage::hasResourceUseSubmitted(Renderer *renderer) const
  {
      return renderer->hasResourceUseSubmitted(mLifetime);
  }
  
  // ReleasableResource implementation.
  template <class T>
  void ReleasableResource<T>::release(Renderer *renderer)
  {
      renderer->collectGarbage(mUse, &mObject);
  }
  
  template class ReleasableResource<Semaphore>;
  }  // namespace vk
  }  // namespace rx
  

Download