impeller::CommandPoolRecyclerVK Class Reference

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

#include <command_pool_vk.h>

Inheritance diagram for impeller::CommandPoolRecyclerVK:

Classes
struct	RecycledData
	A unique command pool and zero or more recycled command buffers. More...

Public Member Functions
void	DestroyThreadLocalPools ()
	Clean up resources held by all per-thread command pools associated with the context. More...
	CommandPoolRecyclerVK (const std::shared_ptr< ContextVK > &context)
	Creates a recycler for the given |ContextVK|. More...
std::shared_ptr< CommandPoolVK >	Get ()
	Gets a command pool for the current thread. More...
void	Reclaim (vk::UniqueCommandPool &&pool, std::vector< vk::UniqueCommandBuffer > &&buffers, bool should_trim=false)
	Returns a command pool to be reset on a background thread. More...
void	Dispose ()
	Clears this context's thread-local command pool. More...

Static Public Member Functions
static int	GetGlobalPoolCount (const ContextVK &context)

Detailed Description

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

A |vk::CommandPool| is expensive to create and reset. This class manages the lifecycle of |vk::CommandPool| objects by creating and recycling them; or in other words, a pool for command pools.

A single instance should be created per |ContextVK|.

Every "frame", a single |CommandPoolResourceVk| is made available for each thread that calls |Get|. After calling |Dispose|, the current thread's pool is moved to a background thread, reset, and made available for the next time |Get| is called and needs to create a command pool.

Commands in the command pool are not necessarily done executing when the pool is recycled, when all references are dropped to the pool, they are reset and returned to the pool of available pools.

Note

This class is thread-safe.

See also

|vk::CommandPoolResourceVk|

|ContextVK|

https://arm-software.github.io/vulkan_best_practice_for_mobile_developers/samples/performance/command_buffer_usage/command_buffer_usage_tutorial.html

Definition at line 103 of file command_pool_vk.h.

Constructor & Destructor Documentation

CommandPoolRecyclerVK()

impeller::CommandPoolRecyclerVK::CommandPoolRecyclerVK ( const std::shared_ptr< ContextVK > &  context )

explicit

Creates a recycler for the given |ContextVK|.

Parameters

[in]

context

The context to create the recycler for.

Definition at line 178 of file command_pool_vk.cc.

    : context_(context), context_hash_(context->GetHash()) {}

Member Function Documentation

DestroyThreadLocalPools()

void impeller::CommandPoolRecyclerVK::DestroyThreadLocalPools

(

)

Clean up resources held by all per-thread command pools associated with the context.

Definition at line 306 of file command_pool_vk.cc.

                                                    {
  // Delete the context's entry in this thread's command pool map.
  if (tls_command_pool_map.get()) {
    tls_command_pool_map.get()->erase(context_hash_);
  }
 
  // Destroy all other thread-local CommandPoolVK instances associated with
  // this context.
  Lock all_pools_lock(g_all_pools_map_mutex);
  auto found = g_all_pools_map.find(context_hash_);
  if (found != g_all_pools_map.end()) {
    for (auto& [thread_id, weak_pool] : found->second) {
      auto pool = weak_pool.lock();
      if (!pool) {
        continue;
      }
      // Delete all objects held by this pool.  The destroyed pool will still
      // remain in its thread's TLS map until that thread exits.
      pool->Destroy();
    }
    g_all_pools_map.erase(found);
  }
}

References impeller::g_all_pools_map_mutex, and impeller::tls_command_pool_map.

Dispose()

void impeller::CommandPoolRecyclerVK::Dispose

(

)

Clears this context's thread-local command pool.

Definition at line 291 of file command_pool_vk.cc.

                                    {
  CommandPoolMap* pool_map = tls_command_pool_map.get();
  if (pool_map) {
    pool_map->erase(context_hash_);
  }
 
  {
    Lock all_pools_lock(g_all_pools_map_mutex);
    auto found = g_all_pools_map.find(context_hash_);
    if (found != g_all_pools_map.end()) {
      found->second.erase(std::this_thread::get_id());
    }
  }
}

References impeller::g_all_pools_map_mutex, and impeller::tls_command_pool_map.

Get()

std::shared_ptr< CommandPoolVK > impeller::CommandPoolRecyclerVK::Get

(

)

Gets a command pool for the current thread.

Warning

Returns a |nullptr| if a pool could not be created.

Definition at line 191 of file command_pool_vk.cc.

                                                        {
  auto const strong_context = context_.lock();
  if (!strong_context) {
    return nullptr;
  }
 
  // If there is a resource in used for this thread and context, return it.
  if (!tls_command_pool_map.get()) {
    tls_command_pool_map.reset(new CommandPoolMap());
  }
  CommandPoolMap& pool_map = *tls_command_pool_map.get();
  auto const it = pool_map.find(context_hash_);
  if (it != pool_map.end()) {
    return it->second;
  }
 
  // Otherwise, create a new resource and return it.
  auto data = Create();
  if (!data || !data->pool) {
    return nullptr;
  }
 
  auto const resource = std::make_shared<CommandPoolVK>(
      std::move(data->pool), std::move(data->buffers), context_);
  pool_map.emplace(context_hash_, resource);
 
  {
    Lock all_pools_lock(g_all_pools_map_mutex);
    g_all_pools_map[context_hash_][std::this_thread::get_id()] = resource;
  }
 
  return resource;
}

References data, impeller::g_all_pools_map_mutex, and impeller::tls_command_pool_map.

GetGlobalPoolCount()

int impeller::CommandPoolRecyclerVK::GetGlobalPoolCount ( const ContextVK &  context )

static

Definition at line 184 of file command_pool_vk.cc.

                                                                      {
  Lock all_pools_lock(g_all_pools_map_mutex);
  auto it = g_all_pools_map.find(context.GetHash());
  return it != g_all_pools_map.end() ? it->second.size() : 0;
}

References impeller::g_all_pools_map_mutex, and impeller::ContextVK::GetHash().

Referenced by impeller::testing::TEST().

Reclaim()

void impeller::CommandPoolRecyclerVK::Reclaim	(	vk::UniqueCommandPool &&	pool,
		std::vector< vk::UniqueCommandBuffer > &&	buffers,
		bool	should_trim = false
	)

Returns a command pool to be reset on a background thread.

Parameters

[in]	pool	The pool to recycle.
[in]	should_trim	whether to trim command pool memory before reseting.

Definition at line 265 of file command_pool_vk.cc.

                      {
  // Reset the pool on a background thread.
  auto strong_context = context_.lock();
  if (!strong_context) {
    return;
  }
  auto device = strong_context->GetDevice();
  vk::CommandPoolResetFlags flags;
  if (should_trim) {
    buffers.clear();
    flags = vk::CommandPoolResetFlagBits::eReleaseResources;
  }
  const auto result = device.resetCommandPool(pool.get(), flags);
  if (result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Could not reset command pool: " << vk::to_string(result);
  }
 
  // Move the pool to the recycled list.
  Lock recycled_lock(recycled_mutex_);
  recycled_.push_back(
      RecycledData{.pool = std::move(pool), .buffers = std::move(buffers)});
}

References impeller::CommandPoolRecyclerVK::RecycledData::pool, and VALIDATION_LOG.

---

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