impeller::CommandPoolVK Class Reference

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)
	Creates a resource that manages the life of a command pool.
vk::UniqueCommandBuffer	CreateCommandBuffer ()
	Creates and returns a new |vk::CommandBuffer|.
void	CollectCommandBuffer (vk::UniqueCommandBuffer &&buffer)
	Collects the given |vk::CommandBuffer| to be retained.
void	Destroy ()
	Delete all Vulkan objects in this command pool.

Detailed Description

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

A |vk::CommandPool| is expensive to create and reset. This class manages the lifecycle of a single |vk::CommandPool| by returning to the origin (|CommandPoolRecyclerVK|) when it is destroyed to be reused.

Warning

This class is not thread-safe.

See also

|CommandPoolRecyclerVK|

Definition at line 31 of file command_pool_vk.h.

Constructor & Destructor Documentation

~CommandPoolVK()

impeller::CommandPoolVK::~CommandPoolVK

(

)

Definition at line 74 of file command_pool_vk.cc.

                              {
  if (!pool_) {
    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));
}

CommandPoolVK()

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

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 40 of file command_pool_vk.h.

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

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 131 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 103 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]);
}

Destroy()

void impeller::CommandPoolVK::Destroy

(

)

Delete all Vulkan objects in this command pool.

Definition at line 142 of file command_pool_vk.cc.

                            {
  Lock lock(pool_mutex_);
  pool_.reset();
 
  // When the command pool is destroyed, all of its command buffers are freed.
  // Handles allocated from that pool are now invalid and must be discarded.
  for (auto& buffer : collected_buffers_) {
    buffer.release();
  }
  for (auto& buffer : unused_command_buffers_) {
    buffer.release();
  }
  unused_command_buffers_.clear();
  collected_buffers_.clear();
}

---

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

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