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

• Show log

  Commit

• Hash : 684ff60b
  Author :
  Date : 2022-06-21T10:52:31
  

  Vulkan: Add shared ring buffer cmd alloc feature
  
  * Added RingBufferAllocator.cpp with implementation.
    * Main classes:
      * RingBufferAllocator (fast allocation with bulk deallocation)
      * SharedRingBufferAllocator (wrapper to help with shared use and
      multiple threads)
  
  * Implemented "angle_enable_vulkan_shared_ring_buffer_cmd_alloc"
  feature. (Disabled by default)
    * Details (from the original CL)
      * The angle::PoolAllocator replaced with
      angle::RingBufferAllocator.
  
      * Before, there was separate angle::PoolAllocator per each
      CommandBufferHelper. Now, a single angle::RingBufferAllocator
      is shared between multiple CommandBufferHelper objects.
  
      * Commands data from multiple CommandBufferHelpers is
      tightly packed without fragmentation.
  
    * Significantly less memory overhead, observed with enabled
      async queue.
  
  * Moved the parts of the code related to the allocators into the
    classes in the new AllocatorHelperPool and AllocatorHelperRing files
    for better management. The allocator can be switched by changing the
    following BUILD flag:
    `angle_enable_vulkan_shared_ring_buffer_cmd_alloc`
  
      * It is connected to the following macro:
        ANGLE_ENABLE_VULKAN_SHARED_RING_BUFFER_CMD_ALLOC
  
    * The two main allocator classes in each file are aliased as:
      * SecondaryCommandBlockAllocator (in CommandBufferHelper objects)
      * SecondaryCommandBlockPool (in SecondaryCommandBuffer)
  
    * Also added placeholder functions for VulkanSecondaryCommandBuffer.
  
  * Added descriptions regarding the two allocators.
    * renderer/vulkan/doc/Allocators.md
  
  Credit: Original CL authored by Igor Nazarov <i.nazarov@samsung.com>
  
  Bug: angleproject:6401
  Bug: b/256666069
  Change-Id: I0f24793eef6334bf4ff8e327b9665338807dad37
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3715968
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Amirali Abdolrashidi <abdolrashidi@google.com>
  

Download

• src/libANGLE/renderer/vulkan/AllocatorHelperRing.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.
  //
  // AllocatorHelperRing:
  //    Implements the ring buffer allocator helpers used in the command buffers.
  //
  
  #include "libANGLE/renderer/vulkan/AllocatorHelperRing.h"
  #include "libANGLE/renderer/vulkan/SecondaryCommandBuffer.h"
  
  namespace rx
  {
  namespace vk
  {
  
  void SharedCommandBlockAllocator::resetAllocator()
  {
      ASSERT(!mAllocator || !mAllocator->isShared());
  
      if (mAllocSharedCP)
      {
          mAllocSharedCP->releaseAndUpdate(&mAllocReleaseCP);
          mAllocSharedCP = nullptr;
      }
  
      ASSERT(!mAllocSharedCP && !mAllocReleaseCP.valid());
  }
  
  void SharedCommandBlockAllocator::attachAllocator(SharedCommandMemoryAllocator *allocator)
  {
      ASSERT(allocator);
      ASSERT(!mAllocator);
      mAllocator = allocator;
      if (mAllocator->isShared())
      {
          mAllocator->releaseToSharedCP();
      }
  }
  
  SharedCommandMemoryAllocator *SharedCommandBlockAllocator::detachAllocator(
      bool isCommandBufferEmpty)
  {
      if (!isCommandBufferEmpty)
      {
          // Must call reset() after detach from non-empty command buffer (OK to have an empty RP)
          ASSERT(!mAllocSharedCP && !mAllocReleaseCP.valid());
          mAllocSharedCP  = mAllocator->acquireSharedCP();
          mAllocReleaseCP = mAllocator->get().getReleaseCheckPoint();
      }
      SharedCommandMemoryAllocator *result = mAllocator;
      mAllocator                           = nullptr;
      return result;
  }
  
  void SharedCommandBlockPool::attachAllocator(SharedCommandMemoryAllocator *source)
  {
      ASSERT(source);
      RingBufferAllocator &sourceIn = source->get();
  
      ASSERT(sourceIn.valid());
      ASSERT(mCommandBuffer->hasEmptyCommands());
      ASSERT(mLastCommandBlock == nullptr);
      ASSERT(mFinishedCommandSize == 0);
      ASSERT(!mAllocator.valid());
      mAllocator = std::move(sourceIn);
      mAllocator.setFragmentReserve(kCommandHeaderSize);
      pushNewCommandBlock(mAllocator.allocate(0));
      mAllocator.setListener(this);
  }
  
  void SharedCommandBlockPool::detachAllocator(SharedCommandMemoryAllocator *destination)
  {
      ASSERT(destination);
      RingBufferAllocator &destinationOut = destination->get();
      ASSERT(!destinationOut.valid());
  
      ASSERT(mAllocator.valid());
      mAllocator.setListener(nullptr);
      finishLastCommandBlock();
      if (mFinishedCommandSize == 0)
      {
          mCommandBuffer->clearCommands();
      }
      else
      {
          mAllocator.setFragmentReserve(0);
          (void)mAllocator.allocate(sizeof(kCommandHeaderSize));
      }
      destinationOut = std::move(mAllocator);
  }
  
  uint32_t SharedCommandBlockPool::getCommandSize() const
  {
      uint32_t result = mFinishedCommandSize;
      if (mLastCommandBlock)
      {
          ASSERT(mAllocator.valid());
          ASSERT(mAllocator.getPointer() >= mLastCommandBlock);
          result += static_cast<uint32_t>(mAllocator.getPointer() - mLastCommandBlock);
      }
      return result;
  }
  
  void SharedCommandBlockPool::pushNewCommandBlock(uint8_t *block)
  {
      mLastCommandBlock = block;
      mCommandBuffer->pushToCommands(block);
  }
  
  void SharedCommandBlockPool::getMemoryUsageStats(size_t *usedMemoryOut,
                                                   size_t *allocatedMemoryOut) const
  {
      *usedMemoryOut      = getCommandSize();
      *allocatedMemoryOut = getCommandSize();
  }
  
  }  // namespace vk
  }  // namespace rx
  

Download