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

• Show log

  Commit

• Hash : bc3be5a8
  Author :
  Date : 2022-01-27T12:12:58
  

  Vulkan: Add a dedicated suballocation garbage list
  
  Suballocations are the most common garbage objects in most usage cases.
  The current garbage collection code will construct a garbage object from
  suballocation and then construct a SharedGarbage object with a
  std::vector that holds only one element. And then it adds this
  SharedGarbage to the garbage list. This CL tries to avoid create
  std::vector with just one element and avoid the cost of switch statement
  for each garbage object by adding a new dedicated garbage list that only
  holds the suballocation garbages, which is the most common garbages in
  the system. With gardenscapes running offscreen with --minimum-gpu-work,
  it reduces CPU overhead from 2.55ms to 2.20ms on Pixel6.
  
  Bug: b/215768827
  Change-Id: Ia2872442462917c0caadb263769a1cbf3dd7366f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3414356
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

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

• //
  // 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.
  //
  // ResourceVk:
  //    Resource lifetime tracking in the Vulkan back-end.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_RESOURCEVK_H_
  #define LIBANGLE_RENDERER_VULKAN_RESOURCEVK_H_
  
  #include "libANGLE/renderer/vulkan/vk_utils.h"
  
  #include <queue>
  
  namespace rx
  {
  namespace vk
  {
  // Tracks how a resource is used by ANGLE and by a VkQueue. The reference count indicates the number
  // of times a resource is retained by ANGLE. The serial indicates the most recent use of a resource
  // in the VkQueue. The reference count and serial together can determine if a resource is currently
  // in use.
  struct ResourceUse
  {
      ResourceUse() = default;
  
      // The number of times a resource is retained by ANGLE.
      uint32_t counter = 0;
  
      // The most recent time of use in a VkQueue.
      Serial serial;
  };
  
  class SharedResourceUse final : angle::NonCopyable
  {
    public:
      SharedResourceUse() : mUse(nullptr) {}
      ~SharedResourceUse() { ASSERT(!valid()); }
      SharedResourceUse(SharedResourceUse &&rhs) : mUse(rhs.mUse) { rhs.mUse = nullptr; }
      SharedResourceUse &operator=(SharedResourceUse &&rhs)
      {
          std::swap(mUse, rhs.mUse);
          return *this;
      }
  
      ANGLE_INLINE bool valid() const { return mUse != nullptr; }
  
      void init()
      {
          ASSERT(!mUse);
          mUse = new ResourceUse;
          mUse->counter++;
      }
  
      // Specifically for use with command buffers that are used as one-offs.
      void updateSerialOneOff(Serial serial) { mUse->serial = serial; }
  
      ANGLE_INLINE void release()
      {
          ASSERT(valid());
          ASSERT(mUse->counter > 0);
          if (--mUse->counter == 0)
          {
              delete mUse;
          }
          mUse = nullptr;
      }
  
      ANGLE_INLINE void releaseAndUpdateSerial(Serial serial)
      {
          ASSERT(valid());
          ASSERT(mUse->counter > 0);
          ASSERT(mUse->serial <= serial);
          mUse->serial = serial;
          release();
      }
  
      ANGLE_INLINE void set(const SharedResourceUse &rhs)
      {
          ASSERT(rhs.valid());
          ASSERT(!valid());
          ASSERT(rhs.mUse->counter < std::numeric_limits<uint32_t>::max());
          mUse = rhs.mUse;
          mUse->counter++;
      }
  
      // The base counter value for a live resource is "1". Any value greater than one indicates
      // the resource is in use by a command buffer.
      ANGLE_INLINE bool usedInRecordedCommands() const
      {
          ASSERT(valid());
          return mUse->counter > 1;
      }
  
      ANGLE_INLINE bool usedInRunningCommands(Serial lastCompletedSerial) const
      {
          ASSERT(valid());
          return mUse->serial > lastCompletedSerial;
      }
  
      ANGLE_INLINE bool isCurrentlyInUse(Serial lastCompletedSerial) const
      {
          return usedInRecordedCommands() || usedInRunningCommands(lastCompletedSerial);
      }
  
      ANGLE_INLINE Serial getSerial() const
      {
          ASSERT(valid());
          return mUse->serial;
      }
  
    private:
      ResourceUse *mUse;
  };
  
  class SharedBufferSuballocationGarbage
  {
    public:
      SharedBufferSuballocationGarbage() = default;
      SharedBufferSuballocationGarbage(SharedBufferSuballocationGarbage &&other)
          : mLifetime(std::move(other.mLifetime)), mGarbage(std::move(other.mGarbage))
      {}
      SharedBufferSuballocationGarbage(SharedResourceUse &&use, BufferSuballocation &&garbage)
          : mLifetime(std::move(use)), mGarbage(std::move(garbage))
      {}
      ~SharedBufferSuballocationGarbage() = default;
  
      bool destroyIfComplete(RendererVk *renderer, Serial completedSerial);
  
    private:
      SharedResourceUse mLifetime;
      BufferSuballocation mGarbage;
  };
  using SharedBufferSuballocationGarbageList = std::queue<SharedBufferSuballocationGarbage>;
  
  class SharedGarbage
  {
    public:
      SharedGarbage();
      SharedGarbage(SharedGarbage &&other);
      SharedGarbage(SharedResourceUse &&use, std::vector<GarbageObject> &&garbage);
      ~SharedGarbage();
      SharedGarbage &operator=(SharedGarbage &&rhs);
  
      bool destroyIfComplete(RendererVk *renderer, Serial completedSerial);
  
    private:
      SharedResourceUse mLifetime;
      std::vector<GarbageObject> mGarbage;
  };
  
  using SharedGarbageList = std::queue<SharedGarbage>;
  
  // Mixin to abstract away the resource use tracking.
  class ResourceUseList final : angle::NonCopyable
  {
    public:
      ResourceUseList();
      ResourceUseList(ResourceUseList &&other);
      virtual ~ResourceUseList();
      ResourceUseList &operator=(ResourceUseList &&rhs);
  
      void add(const SharedResourceUse &resourceUse);
  
      void releaseResourceUses();
      void releaseResourceUsesAndUpdateSerials(Serial serial);
  
      bool empty() { return mResourceUses.empty(); }
  
    private:
      std::vector<SharedResourceUse> mResourceUses;
  };
  
  ANGLE_INLINE void ResourceUseList::add(const SharedResourceUse &resourceUse)
  {
      SharedResourceUse newUse;
      newUse.set(resourceUse);
      mResourceUses.emplace_back(std::move(newUse));
  }
  
  // This is a helper class for back-end objects used in Vk command buffers. They keep a record
  // of their use in ANGLE and VkQueues via SharedResourceUse.
  class Resource : angle::NonCopyable
  {
    public:
      virtual ~Resource();
  
      // Returns true if the resource is used by ANGLE in an unflushed command buffer.
      bool usedInRecordedCommands() const { return mUse.usedInRecordedCommands(); }
  
      // Determine if the driver has finished execution with this resource.
      bool usedInRunningCommands(Serial lastCompletedSerial) const
      {
          return mUse.usedInRunningCommands(lastCompletedSerial);
      }
  
      // Returns true if the resource is in use by ANGLE or the driver.
      bool isCurrentlyInUse(Serial lastCompletedSerial) const
      {
          return mUse.isCurrentlyInUse(lastCompletedSerial);
      }
  
      // Ensures the driver is caught up to this resource and it is only in use by ANGLE.
      angle::Result finishRunningCommands(ContextVk *contextVk);
  
      // Complete all recorded and in-flight commands involving this resource
      angle::Result waitForIdle(ContextVk *contextVk,
                                const char *debugMessage,
                                RenderPassClosureReason reason);
  
      // Adds the resource to a resource use list.
      void retain(ResourceUseList *resourceUseList) const;
  
    protected:
      Resource();
      Resource(Resource &&other);
      Resource &operator=(Resource &&rhs);
  
      // Current resource lifetime.
      SharedResourceUse mUse;
  };
  
  ANGLE_INLINE void Resource::retain(ResourceUseList *resourceUseList) const
  {
      // Store reference in resource list.
      resourceUseList->add(mUse);
  }
  
  // Similar to |Resource| above, this tracks object usage. This includes additional granularity to
  // track whether an object is used for read-only or read/write access.
  class ReadWriteResource : public angle::NonCopyable
  {
    public:
      virtual ~ReadWriteResource();
  
      // Returns true if the resource is used by ANGLE in an unflushed command buffer.
      bool usedInRecordedCommands() const { return mReadOnlyUse.usedInRecordedCommands(); }
  
      // Determine if the driver has finished execution with this resource.
      bool usedInRunningCommands(Serial lastCompletedSerial) const
      {
          return mReadOnlyUse.usedInRunningCommands(lastCompletedSerial);
      }
  
      // Returns true if the resource is in use by ANGLE or the driver.
      bool isCurrentlyInUse(Serial lastCompletedSerial) const
      {
          return mReadOnlyUse.isCurrentlyInUse(lastCompletedSerial);
      }
      bool isCurrentlyInUseForWrite(Serial lastCompletedSerial) const
      {
          return mReadWriteUse.isCurrentlyInUse(lastCompletedSerial);
      }
  
      // Ensures the driver is caught up to this resource and it is only in use by ANGLE.
      angle::Result finishRunningCommands(ContextVk *contextVk);
  
      // Ensures the GPU write commands is completed.
      angle::Result finishGPUWriteCommands(ContextVk *contextVk);
  
      // Complete all recorded and in-flight commands involving this resource
      angle::Result waitForIdle(ContextVk *contextVk,
                                const char *debugMessage,
                                RenderPassClosureReason reason);
  
      // Adds the resource to a resource use list.
      void retainReadOnly(ResourceUseList *resourceUseList) const;
      void retainReadWrite(ResourceUseList *resourceUseList) const;
  
    protected:
      ReadWriteResource();
      ReadWriteResource(ReadWriteResource &&other);
      ReadWriteResource &operator=(ReadWriteResource &&other);
  
      // Track any use of the object. Always updated on every retain call.
      SharedResourceUse mReadOnlyUse;
      // Track read/write use of the object. Only updated for retainReadWrite().
      SharedResourceUse mReadWriteUse;
  };
  
  ANGLE_INLINE void ReadWriteResource::retainReadOnly(ResourceUseList *resourceUseList) const
  {
      // Store reference in resource list.
      resourceUseList->add(mReadOnlyUse);
  }
  
  ANGLE_INLINE void ReadWriteResource::retainReadWrite(ResourceUseList *resourceUseList) const
  {
      // Store reference in resource list.
      resourceUseList->add(mReadOnlyUse);
      resourceUseList->add(mReadWriteUse);
  }
  
  }  // namespace vk
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_RESOURCEVK_H_
  

Download