A per-frame descriptor pool. Descriptors from this pool don't need to be freed individually. Instead, the pool must be collected after all the descriptors allocated from it are done being used. More...

#include <descriptor_pool_vk.h>

Public Member Functions
	DescriptorPoolVK (std::weak_ptr< const ContextVK > context)

	DescriptorPoolVK (std::weak_ptr< const ContextVK > context, DescriptorCacheMap descriptor_sets, std::vector< vk::UniqueDescriptorPool > pools)

	~DescriptorPoolVK ()

fml::StatusOr< vk::DescriptorSet >	AllocateDescriptorSets (const vk::DescriptorSetLayout &layout, PipelineKey pipeline_key, const ContextVK &context_vk)

Friends
class	DescriptorPoolRecyclerVK

Detailed Description

A per-frame descriptor pool. Descriptors from this pool don't need to be freed individually. Instead, the pool must be collected after all the descriptors allocated from it are done being used.

The pool or it's descriptors may not be accessed from multiple threads.

Encoders create pools as necessary as they have the same threading and lifecycle restrictions.

Definition at line 36 of file descriptor_pool_vk.h.

Constructor & Destructor Documentation

◆ DescriptorPoolVK() [1/2]

impeller::DescriptorPoolVK::DescriptorPoolVK ( std::weak_ptr< const ContextVK > context )

explicit

Definition at line 29 of file descriptor_pool_vk.cc.

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

◆ DescriptorPoolVK() [2/2]

impeller::DescriptorPoolVK::DescriptorPoolVK	(	std::weak_ptr< const ContextVK >	context,
		DescriptorCacheMap	descriptor_sets,
		std::vector< vk::UniqueDescriptorPool >	pools
	)

Definition at line 36 of file descriptor_pool_vk.cc.

    : context_(std::move(context)),
      descriptor_sets_(std::move(descriptor_sets)),
      pools_(std::move(pools)) {}

◆ ~DescriptorPoolVK()

impeller::DescriptorPoolVK::~DescriptorPoolVK ( )

Definition at line 43 of file descriptor_pool_vk.cc.

                                    {
  if (pools_.empty()) {
    return;
  }
 
  auto const context = context_.lock();
  if (!context) {
    return;
  }
  auto const recycler = context->GetDescriptorPoolRecycler();
  if (!recycler) {
    return;
  }
 
  recycler->Reclaim(std::move(descriptor_sets_), std::move(pools_));
}

Member Function Documentation

◆ AllocateDescriptorSets()

fml::StatusOr< vk::DescriptorSet > impeller::DescriptorPoolVK::AllocateDescriptorSets	(	const vk::DescriptorSetLayout &	layout,
		PipelineKey	pipeline_key,
		const ContextVK &	context_vk
	)

Definition at line 60 of file descriptor_pool_vk.cc.

                                 {
  DescriptorCacheMap::iterator existing = descriptor_sets_.find(pipeline_key);
  if (existing != descriptor_sets_.end() && !existing->second.unused.empty()) {
    auto descriptor_set = existing->second.unused.back();
    existing->second.unused.pop_back();
    existing->second.used.push_back(descriptor_set);
    return descriptor_set;
  }
 
  if (pools_.empty()) {
    CreateNewPool(context_vk);
  }
 
  vk::DescriptorSetAllocateInfo set_info;
  set_info.setDescriptorPool(pools_.back().get());
  set_info.setPSetLayouts(&layout);
  set_info.setDescriptorSetCount(1);
 
  vk::DescriptorSet set;
  auto result = context_vk.GetDevice().allocateDescriptorSets(&set_info, &set);
  if (result == vk::Result::eErrorOutOfPoolMemory) {
    // If the pool ran out of memory, we need to create a new pool.
    CreateNewPool(context_vk);
    set_info.setDescriptorPool(pools_.back().get());
    result = context_vk.GetDevice().allocateDescriptorSets(&set_info, &set);
  }
  auto lookup_result =
      descriptor_sets_.try_emplace(pipeline_key, DescriptorCache{});
  lookup_result.first->second.used.push_back(set);
 
  if (result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not allocate descriptor sets: "
                   << vk::to_string(result);
    return fml::Status(fml::StatusCode::kUnknown, "");
  }
  return set;
}