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

• Show log

  Commit

• Hash : 2608c622
  Author :
  Date : 2023-10-06T13:32:49
  

  Vulkan: Refactor SharedGarbageList into templated class
  
  This CL mostly involves non-functional changes to prepare for next CL.
  No behavior change is expected.
  
  This CL wraps the garbage list into its own templated class which
  maintains std::queue and tracks number bytes in the queue etc.
  
  This CL also renames SharedBufferSuballocationGarbageList to
  BufferSuballocationGarbageList to reduce verbosity a bit.
  
  This CL deleted GarbageAndQueueSerial and GarbageQueue since they are no
  longer being used.
  
  This renames vk::GarbageList to vk::GarbageObjects to reduce name
  confusion with SharedGarbageList.
  
  Bug: b/302739073
  Change-Id: I7370c147847ffe69ad8aa3b48251d8b5762f97f9
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4919816
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Hailin Zhang <hailinzhang@google.com>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

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

• //
  // Copyright 2022 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.
  //
  // Suballocation.cpp:
  //    Implements class methods for BufferBlock and Suballocation and other related classes
  //
  
  // #include "libANGLE/renderer/vulkan/vk_utils.h"
  
  #include "libANGLE/renderer/vulkan/Suballocation.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/renderer/vulkan/RendererVk.h"
  #include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"
  
  namespace rx
  {
  namespace vk
  {
  // BufferBlock implementation.
  BufferBlock::BufferBlock()
      : mMemoryPropertyFlags(0),
        mSize(0),
        mAllocatedBufferSize(0),
        mMemoryAllocationType(MemoryAllocationType::InvalidEnum),
        mMemoryTypeIndex(kInvalidMemoryTypeIndex),
        mMappedMemory(nullptr)
  {}
  
  BufferBlock::BufferBlock(BufferBlock &&other)
      : mVirtualBlock(std::move(other.mVirtualBlock)),
        mBuffer(std::move(other.mBuffer)),
        mDeviceMemory(std::move(other.mDeviceMemory)),
        mMemoryPropertyFlags(other.mMemoryPropertyFlags),
        mSize(other.mSize),
        mAllocatedBufferSize(other.mAllocatedBufferSize),
        mMemoryAllocationType(other.mMemoryAllocationType),
        mMemoryTypeIndex(other.mMemoryTypeIndex),
        mMappedMemory(other.mMappedMemory),
        mSerial(other.mSerial),
        mCountRemainsEmpty(0)
  {}
  
  BufferBlock &BufferBlock::operator=(BufferBlock &&other)
  {
      std::swap(mVirtualBlock, other.mVirtualBlock);
      std::swap(mBuffer, other.mBuffer);
      std::swap(mDeviceMemory, other.mDeviceMemory);
      std::swap(mMemoryPropertyFlags, other.mMemoryPropertyFlags);
      std::swap(mSize, other.mSize);
      std::swap(mAllocatedBufferSize, other.mAllocatedBufferSize);
      std::swap(mMemoryAllocationType, other.mMemoryAllocationType);
      std::swap(mMemoryTypeIndex, other.mMemoryTypeIndex);
      std::swap(mMappedMemory, other.mMappedMemory);
      std::swap(mSerial, other.mSerial);
      std::swap(mCountRemainsEmpty, other.mCountRemainsEmpty);
      return *this;
  }
  
  BufferBlock::~BufferBlock()
  {
      ASSERT(!mVirtualBlock.valid());
      ASSERT(!mBuffer.valid());
      ASSERT(!mDeviceMemory.valid());
      ASSERT(mDescriptorSetCacheManager.empty());
  }
  
  void BufferBlock::destroy(RendererVk *renderer)
  {
      VkDevice device = renderer->getDevice();
  
      mDescriptorSetCacheManager.destroyKeys(renderer);
      if (mMappedMemory)
      {
          unmap(device);
      }
  
      renderer->onMemoryDealloc(mMemoryAllocationType, mAllocatedBufferSize, mMemoryTypeIndex,
                                mDeviceMemory.getHandle());
  
      mVirtualBlock.destroy(device);
      mBuffer.destroy(device);
      mDeviceMemory.destroy(device);
  }
  
  VkResult BufferBlock::init(Context *context,
                             Buffer &buffer,
                             uint32_t memoryTypeIndex,
                             vma::VirtualBlockCreateFlags flags,
                             DeviceMemory &deviceMemory,
                             VkMemoryPropertyFlags memoryPropertyFlags,
                             VkDeviceSize size)
  {
      RendererVk *renderer = context->getRenderer();
      ASSERT(!mVirtualBlock.valid());
      ASSERT(!mBuffer.valid());
      ASSERT(!mDeviceMemory.valid());
  
      VK_RESULT_TRY(mVirtualBlock.init(renderer->getDevice(), flags, size));
  
      mBuffer               = std::move(buffer);
      mDeviceMemory         = std::move(deviceMemory);
      mMemoryPropertyFlags  = memoryPropertyFlags;
      mSize                 = size;
      mAllocatedBufferSize  = size;
      mMemoryAllocationType = MemoryAllocationType::Buffer;
      mMemoryTypeIndex      = memoryTypeIndex;
      mMappedMemory         = nullptr;
      mSerial               = renderer->getResourceSerialFactory().generateBufferSerial();
  
      return VK_SUCCESS;
  }
  
  void BufferBlock::initWithoutVirtualBlock(Context *context,
                                            Buffer &buffer,
                                            MemoryAllocationType memoryAllocationType,
                                            uint32_t memoryTypeIndex,
                                            DeviceMemory &deviceMemory,
                                            VkMemoryPropertyFlags memoryPropertyFlags,
                                            VkDeviceSize size,
                                            VkDeviceSize allocatedBufferSize)
  {
      RendererVk *renderer = context->getRenderer();
      ASSERT(!mVirtualBlock.valid());
      ASSERT(!mBuffer.valid());
      ASSERT(!mDeviceMemory.valid());
  
      mBuffer               = std::move(buffer);
      mDeviceMemory         = std::move(deviceMemory);
      mMemoryPropertyFlags  = memoryPropertyFlags;
      mSize                 = size;
      mAllocatedBufferSize  = allocatedBufferSize;
      mMemoryAllocationType = memoryAllocationType;
      mMemoryTypeIndex      = memoryTypeIndex;
      mMappedMemory         = nullptr;
      mSerial               = renderer->getResourceSerialFactory().generateBufferSerial();
  }
  
  VkResult BufferBlock::map(const VkDevice device)
  {
      ASSERT(mMappedMemory == nullptr);
      return mDeviceMemory.map(device, 0, mSize, 0, &mMappedMemory);
  }
  
  void BufferBlock::unmap(const VkDevice device)
  {
      mDeviceMemory.unmap(device);
      mMappedMemory = nullptr;
  }
  
  VkResult BufferBlock::allocate(VkDeviceSize size,
                                 VkDeviceSize alignment,
                                 VmaVirtualAllocation *allocationOut,
                                 VkDeviceSize *offsetOut)
  {
      std::unique_lock<std::mutex> lock(mVirtualBlockMutex);
      mCountRemainsEmpty = 0;
      return mVirtualBlock.allocate(size, alignment, allocationOut, offsetOut);
  }
  
  void BufferBlock::free(VmaVirtualAllocation allocation, VkDeviceSize offset)
  {
      std::unique_lock<std::mutex> lock(mVirtualBlockMutex);
      mVirtualBlock.free(allocation, offset);
  }
  
  int32_t BufferBlock::getAndIncrementEmptyCounter()
  {
      return ++mCountRemainsEmpty;
  }
  
  void BufferBlock::calculateStats(vma::StatInfo *pStatInfo) const
  {
      std::unique_lock<std::mutex> lock(mVirtualBlockMutex);
      mVirtualBlock.calculateStats(pStatInfo);
  }
  
  // BufferSuballocation implementation.
  VkResult BufferSuballocation::map(Context *context)
  {
      return mBufferBlock->map(context->getDevice());
  }
  
  // BufferSuballocationGarbage implementation.
  bool BufferSuballocationGarbage::destroyIfComplete(RendererVk *renderer)
  {
      if (renderer->hasResourceUseFinished(mLifetime))
      {
          mBuffer.destroy(renderer->getDevice());
          mSuballocation.destroy(renderer);
          return true;
      }
      return false;
  }
  
  bool BufferSuballocationGarbage::hasResourceUseSubmitted(RendererVk *renderer) const
  {
      return renderer->hasResourceUseSubmitted(mLifetime);
  }
  }  // namespace vk
  }  // namespace rx
  

Download