Manages the lifecycle of a single |vk::CommandPool|. More...

#include <command_pool_vk.h>

Public Member Functions
	~CommandPoolVK ()

	CommandPoolVK (vk::UniqueCommandPool pool, std::vector< vk::UniqueCommandBuffer > &&buffers, std::weak_ptr< ContextVK > context, std::weak_ptr< DeviceHolderVK > device_holder)
	Creates a resource that manages the life of a command pool. More...

vk::UniqueCommandBuffer	CreateCommandBuffer ()
	Creates and returns a new \|vk::CommandBuffer\|. More...

void	CollectCommandBuffer (vk::UniqueCommandBuffer &&buffer)
	Collects the given \|vk::CommandBuffer\| to be retained. More...

Detailed Description

Manages the lifecycle of a single |vk::CommandPool|.

Warning: This class is not thread-safe.

See also: |CommandPoolRecyclerVK|

Definition at line 32 of file command_pool_vk.h.

Constructor & Destructor Documentation

◆ ~CommandPoolVK()

impeller::CommandPoolVK::~CommandPoolVK ( )

Definition at line 72 of file command_pool_vk.cc.

                               {
   if (!pool_) {
     return;
   }
  
   std::shared_ptr<DeviceHolderVK> device_holder = device_holder_.lock();
   if (!device_holder) {
     pool_.release();
     for (auto& buffer : collected_buffers_) {
       buffer.release();
     }
     for (auto& buffer : unused_command_buffers_) {
       buffer.release();
     }
     return;
   }
  
   auto const context = context_.lock();
   if (!context) {
     return;
   }
   auto const recycler = context->GetCommandPoolRecycler();
   if (!recycler) {
     return;
   }
   // Any unused command buffers are added to the set of used command buffers.
   // both will be reset to the initial state when the pool is reset.
   size_t unused_count = unused_command_buffers_.size();
   for (auto i = 0u; i < unused_command_buffers_.size(); i++) {
     collected_buffers_.push_back(std::move(unused_command_buffers_[i]));
   }
   unused_command_buffers_.clear();
  
   auto reset_pool_when_dropped = BackgroundCommandPoolVK(
       std::move(pool_), std::move(collected_buffers_), unused_count, recycler);
  
   UniqueResourceVKT<BackgroundCommandPoolVK> pool(
       context->GetResourceManager(), std::move(reset_pool_when_dropped));
 }

References context.

◆ CommandPoolVK()

impeller::CommandPoolVK::CommandPoolVK	(	vk::UniqueCommandPool	pool,
		std::vector< vk::UniqueCommandBuffer > &&	buffers,
		std::weak_ptr< ContextVK >	context,
		std::weak_ptr< DeviceHolderVK >	device_holder
	)

inline

Creates a resource that manages the life of a command pool.

Parameters

[in]	pool	The command pool to manage.
[in]	buffers	Zero or more command buffers in an initial state.
[in]	recycler	The context that will be notified on destruction.

Definition at line 41 of file command_pool_vk.h.

       : pool_(std::move(pool)),
         unused_command_buffers_(std::move(buffers)),
         context_(std::move(context)),
         device_holder_(std::move(device_holder)) {}

Member Function Documentation

◆ CollectCommandBuffer()

void impeller::CommandPoolVK::CollectCommandBuffer ( vk::UniqueCommandBuffer && buffer )

Collects the given |vk::CommandBuffer| to be retained.

Parameters

[in] buffer The |vk::CommandBuffer| to collect.

See also: |GarbageCollectBuffersIfAble|

Definition at line 141 of file command_pool_vk.cc.

                                                                        {
   Lock lock(pool_mutex_);
   if (!pool_) {
     // If the command pool has already been destroyed, then its buffers have
     // already been freed.
     buffer.release();
     return;
   }
   collected_buffers_.push_back(std::move(buffer));
 }

◆ CreateCommandBuffer()

vk::UniqueCommandBuffer impeller::CommandPoolVK::CreateCommandBuffer ( )

Creates and returns a new |vk::CommandBuffer|.

Returns: Always returns a new |vk::CommandBuffer|, but if for any reason a valid command buffer could not be created, it will be a {} default instance (i.e. while being torn down).

Definition at line 113 of file command_pool_vk.cc.

                                                          {
   auto const context = context_.lock();
   if (!context) {
     return {};
   }
  
   Lock lock(pool_mutex_);
   if (!pool_) {
     return {};
   }
   if (!unused_command_buffers_.empty()) {
     vk::UniqueCommandBuffer buffer = std::move(unused_command_buffers_.back());
     unused_command_buffers_.pop_back();
     return buffer;
   }
  
   auto const device = context->GetDevice();
   vk::CommandBufferAllocateInfo info;
   info.setCommandPool(pool_.get());
   info.setCommandBufferCount(1u);
   info.setLevel(vk::CommandBufferLevel::ePrimary);
   auto [result, buffers] = device.allocateCommandBuffersUnique(info);
   if (result != vk::Result::eSuccess) {
     return {};
   }
   return std::move(buffers[0]);
 }