impeller::DescriptorPoolRecyclerVK Class Reference

Creates and manages the lifecycle of |vk::DescriptorPoolVK| objects. More...

#include <descriptor_pool_vk.h>

Inheritance diagram for impeller::DescriptorPoolRecyclerVK:

Public Member Functions
	~DescriptorPoolRecyclerVK ()=default
	DescriptorPoolRecyclerVK (std::weak_ptr< ContextVK > context)
	Creates a recycler for the given |ContextVK|. More...
DescriptorPoolAndSize	Get (uint32_t minimum_capacity)
	Gets a descriptor pool with at least [minimum_capacity] sampler and slots. More...
void	Reclaim (vk::UniqueDescriptorPool &&pool, uint32_t allocated_capacity)
	Returns the descriptor pool to be reset on a background thread. More...

Static Public Attributes
static constexpr size_t	kMaxRecycledPools = 32u
	The maximum number of descriptor pools this recycler will hold onto. More...

Detailed Description

Creates and manages the lifecycle of |vk::DescriptorPoolVK| objects.

To make descriptor pool recycling more effective, the number of requusted descriptor slots is rounded up the nearest power of two. This also makes determining whether a recycled pool has sufficient slots easier as only a single number comparison is required.

We round up to a minimum of 64 as the smallest power of two to reduce the range of potential allocations to approximately: 64, 128, 256, 512, 1024, 2048, 4096. Beyond this size applications will have far too many drawing commands to render correctly. We also limit the number of cached descriptor pools to 32, which is somewhat arbitrarily chosen, but given 2-ish frames in flight is about 16 descriptors pools per frame which is extremely generous.

Definition at line 67 of file descriptor_pool_vk.h.

Constructor & Destructor Documentation

~DescriptorPoolRecyclerVK()

impeller::DescriptorPoolRecyclerVK::~DescriptorPoolRecyclerVK ( )

default

DescriptorPoolRecyclerVK()

impeller::DescriptorPoolRecyclerVK::DescriptorPoolRecyclerVK ( std::weak_ptr< ContextVK >  context )

inlineexplicit

Creates a recycler for the given |ContextVK|.

Parameters

[in]

context

The context to create the recycler for.

Definition at line 78 of file descriptor_pool_vk.h.

      : context_(std::move(context)) {}

Member Function Documentation

Get()

DescriptorPoolAndSize impeller::DescriptorPoolRecyclerVK::Get

(

uint32_t

minimum_capacity

)

Gets a descriptor pool with at least [minimum_capacity] sampler and slots.

This may create a new descriptor pool if no existing pools had the necessary capacity.

Definition at line 158 of file descriptor_pool_vk.cc.

                                                                             {
  // See note on DescriptorPoolRecyclerVK doc comment.
  auto rounded_capacity =
      std::max(Allocation::NextPowerOfTwoSize(minimum_capacity), 64u);
 
  // Recycle a pool with a matching minumum capcity if it is available.
  auto recycled_pool = Reuse(rounded_capacity);
  if (recycled_pool.has_value()) {
    return std::move(recycled_pool.value());
  }
  return Create(rounded_capacity);
}

References impeller::Allocation::NextPowerOfTwoSize().

Reclaim()

void impeller::DescriptorPoolRecyclerVK::Reclaim	(	vk::UniqueDescriptorPool &&	pool,
		uint32_t	allocated_capacity
	)

Returns the descriptor pool to be reset on a background thread.

Parameters

[in]

pool

The pool to recycler.

Definition at line 117 of file descriptor_pool_vk.cc.

                                                                    {
  // Reset the pool on a background thread.
  auto strong_context = context_.lock();
  if (!strong_context) {
    return;
  }
  auto device = strong_context->GetDevice();
  device.resetDescriptorPool(pool.get());
 
  // Move the pool to the recycled list.
  Lock recycled_lock(recycled_mutex_);
 
  if (recycled_.size() < kMaxRecycledPools) {
    recycled_.push_back(std::make_pair(std::move(pool), allocated_capacity));
    return;
  }
 
  // If recycled has exceeded the max size of 32, then we need to remove a pool
  // from the list. If we were to drop this pool, then there is a risk that
  // the list of recycled descriptor pools could fill up with descriptors that
  // are too small to reuse. This would lead to all subsequent descriptor
  // allocations no longer being recycled. Instead, we pick the first
  // descriptor pool with a smaller capacity than the reseting pool to drop.
  // This may result in us dropping the current pool instead.
  std::optional<size_t> selected_index = std::nullopt;
  for (auto i = 0u; i < recycled_.size(); i++) {
    const auto& [_, capacity] = recycled_[i];
    if (capacity < allocated_capacity) {
      selected_index = i;
      break;
    }
  }
  if (selected_index.has_value()) {
    recycled_[selected_index.value()] =
        std::make_pair(std::move(pool), allocated_capacity);
  }
  // If selected index has no value, then no pools had a smaller capacity than
  // this one and we drop it instead.
}

References kMaxRecycledPools.

Member Data Documentation

kMaxRecycledPools

constexpr size_t impeller::DescriptorPoolRecyclerVK::kMaxRecycledPools = 32u

staticconstexpr

The maximum number of descriptor pools this recycler will hold onto.

Definition at line 73 of file descriptor_pool_vk.h.

Referenced by Reclaim().

---

The documentation for this class was generated from the following files:

• impeller/renderer/backend/vulkan/descriptor_pool_vk.h
• impeller/renderer/backend/vulkan/descriptor_pool_vk.cc