| Flutter Impeller |

Public Member Functions | Static Public Member Functions | List of all members
impeller::CommandPoolRecyclerVK Class Referencefinal

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

`#include <command_pool_vk.h>`

Inheritance diagram for impeller::CommandPoolRecyclerVK:

## Public Member Functions
| ~CommandPoolRecyclerVK ()
| CommandPoolRecyclerVK (std::weak_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)
| Returns a command pool to be reset on a background thread. More...
void | Dispose ()
| Clears all recycled command pools to let them be reclaimed. More...

## Static Public Member Functions
static void | DestroyThreadLocalPools (const ContextVK *context)
| Clean up resources held by all per-thread command pools associated with the given context. More...

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

## Constructor & Destructor Documentation

## ◆ ~CommandPoolRecyclerVK()

impeller::CommandPoolRecyclerVK::~CommandPoolRecyclerVK | ( |  | ) |

Definition at line 228 of file command_pool_vk.cc.

228 {
229 // Ensure all recycled pools are reclaimed before this is destroyed.
230 Dispose();
231 }

References Dispose().

## ◆ CommandPoolRecyclerVK()

impeller::CommandPoolRecyclerVK::CommandPoolRecyclerVK | ( | std::weak_ptr< ContextVK > | context | ) |
| inline explicit

Creates a recycler for the given |ContextVK|.

Parameters

  [in] | context | The context to create the recycler for.

Definition at line 112 of file command_pool_vk.h.

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

## Member Function Documentation

## ◆ DestroyThreadLocalPools()

void impeller::CommandPoolRecyclerVK::DestroyThreadLocalPools | ( | const ContextVK * | context | ) |
| static

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

Parameters

  [in] | context | The context.

Definition at line 240 of file command_pool_vk.cc.

240 {
241 // Delete the context's entry in this thread's command pool map.
242 if (tls_command_pool_map.get()) {
243 tls_command_pool_map.get()->erase(context->GetHash());
244 }
245
246 // Destroy all other thread-local CommandPoolVK instances associated with
247 // this context.
248 Lock all_pools_lock(g_all_pools_map_mutex);
249 auto found = g_all_pools_map.find(context);
250 if (found != g_all_pools_map.end()) {
251 for (auto& weak_pool : found->second) {
252 auto pool = weak_pool.lock();
253 if (!pool) {
254 continue;
255 }
256 // Delete all objects held by this pool. The destroyed pool will still
257 // remain in its thread's TLS map until that thread exits.
258 pool->Destroy();
259 }
260 g_all_pools_map.erase(found);
261 }
262 }

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

Referenced by impeller::ContextVK::~ContextVK().

## ◆ Dispose()

void impeller::CommandPoolRecyclerVK::Dispose | ( |  | ) |

Clears all recycled command pools to let them be reclaimed.

Definition at line 233 of file command_pool_vk.cc.

233 {
234 CommandPoolMap* pool_map = tls_command_pool_map.get();
235 if (pool_map) {
236 pool_map->clear();
237 }
238 }

References impeller::tls_command_pool_map.

Referenced by ~CommandPoolRecyclerVK().

## ◆ 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 142 of file command_pool_vk.cc.

142 {
143 auto const strong_context = context_.lock();
144 if (!strong_context) {
145 return nullptr;
146 }
147
148 // If there is a resource in used for this thread and context, return it.
149 if (!tls_command_pool_map.get()) {
150 tls_command_pool_map.reset(new CommandPoolMap());
151 }
152 CommandPoolMap& pool_map = *tls_command_pool_map.get();
153 auto const hash = strong_context->GetHash();
154 auto const it = pool_map.find(hash);
155 if (it != pool_map.end()) {
156 return it->second;
157 }
158
159 // Otherwise, create a new resource and return it.
160 auto pool = Create();
161 if (!pool) {
162 return nullptr;
163 }
164
165 auto const resource =
166 std::make_shared<CommandPoolVK>(std::move(*pool), context_);
167 pool_map.emplace(hash, resource);
168
169 {
170 Lock all_pools_lock(g_all_pools_map_mutex);
171 g_all_pools_map[strong_context.get()].push_back(resource);
172 }
173
174 return resource;
175 }

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

## ◆ Reclaim()

void impeller::CommandPoolRecyclerVK::Reclaim | ( | vk::UniqueCommandPool && | pool | ) |

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

Parameters

  [in] | pool | The pool to recycler.

Definition at line 214 of file command_pool_vk.cc.

214 {
215 // Reset the pool on a background thread.
216 auto strong_context = context_.lock();
217 if (!strong_context) {
218 return;
219 }
220 auto device = strong_context->GetDevice();
221 device.resetCommandPool(pool.get());
222
223 // Move the pool to the recycled list.
224 Lock recycled_lock(recycled_mutex_);
225 recycled_.push_back(std::move(pool));
226 }

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

impeller::CommandPoolMap
std::unordered_map< uint64_t, std::shared_ptr< CommandPoolVK > > CommandPoolMap
Definition: command_pool_vk.cc:131
impeller::g_all_pools_map_mutex
static Mutex g_all_pools_map_mutex
Definition: command_pool_vk.cc:136
impeller::CommandPoolRecyclerVK::Dispose
void Dispose()
Clears all recycled command pools to let them be reclaimed.
Definition: command_pool_vk.cc:233
impeller::tls_command_pool_map
FML_THREAD_LOCAL fml::ThreadLocalUniquePtr< CommandPoolMap > tls_command_pool_map
Definition: command_pool_vk.cc:132