Class vulkan_command_pool_t

compute/vulkan/vulkan_queue.cpp:197–409

per-thread Vulkan command pool and command buffer management NOTE: since Vulkan is *not* thread-safe, we need to manage this on our own

//! per-thread Vulkan command pool and command buffer management
//! NOTE: since Vulkan is *not* thread-safe, we need to manage this on our own
struct vulkan_command_pool_t {
	VkCommandPool cmd_pool { nullptr };
	const vulkan_device& dev;
	const vulkan_queue& queue;
	const bool is_secondary { false };
	const bool no_blocking { false };
	const bool fence_wait_polling { false };
	
	vulkan_command_pool_t(const vulkan_device& dev_, const vulkan_queue& queue_, const bool is_secondary_) :
	dev(dev_), queue(queue_), is_secondary(is_secondary_),
	no_blocking(has_flag<COMPUTE_CONTEXT_FLAGS::VULKAN_NO_BLOCKING>(dev.context->get_context_flags())),
	fence_wait_polling(floor::get_vulkan_fence_wait_polling()) {}
	
	~vulkan_command_pool_t() {
		// NOTE: this is called via vulkan_command_pool_destructor_t on thread exit
		{
			GUARD(fence_lock);
			if (auto fences_in_flight = fences_in_use.count(); fences_in_flight > 0) {
				log_warn("#$ fences still in use", fences_in_flight);
			} else {
				for (const auto& fence : fences) {
					vkDestroyFence(dev.device, fence, nullptr);
				}
			}
		}
		if (cmd_pool) {
			vkDestroyCommandPool(dev.device, cmd_pool, nullptr);
		}
	}
	
	struct command_buffer_internal_t {
		vector<shared_ptr<compute_buffer>> retained_buffers;
		vector<vulkan_queue::vulkan_completion_handler_t> completion_handlers;
	};
	
	//! per-thread command buffer and fence count
	//! NOTE: since these are *per-thread* we probably never going to need more than this
	static constexpr const uint32_t cmd_buffer_count { 64 /* make use of optimized bitset */ };
	static constexpr const uint32_t fence_count { 16 };

	safe_mutex cmd_buffers_lock;
	array<VkCommandBuffer, cmd_buffer_count> cmd_buffers GUARDED_BY(cmd_buffers_lock) {};
	array<command_buffer_internal_t, cmd_buffer_count> cmd_buffer_internals GUARDED_BY(cmd_buffers_lock) {};
	bitset<cmd_buffer_count> cmd_buffers_in_use GUARDED_BY(cmd_buffers_lock) {};
	
	safe_mutex fence_lock;
	array<VkFence, fence_count> fences GUARDED_BY(fence_lock) {};
	bitset<fence_count> fences_in_use GUARDED_BY(fence_lock) {};
	
	//! acquire an unused fence
	pair<VkFence, uint32_t> acquire_fence() REQUIRES(!fence_lock) {
		for (uint32_t trial = 0, limiter = 10; trial < limiter; ++trial) {
			{
				GUARD(fence_lock);
				if (!fences_in_use.all()) {
					for (uint32_t i = 0; i < fence_count; ++i) {
						if (!fences_in_use[i]) {
							fences_in_use.set(i);