Method execute

compute/vulkan/vulkan_kernel.cpp:240–465

}

void vulkan_kernel::execute(const compute_queue& cqueue,
							vulkan_command_buffer* external_cmd_buffer,
							const bool& is_cooperative,
							const bool& wait_until_completion,
							const uint32_t& dim floor_unused,
							const uint3& global_work_size,
							const uint3& local_work_size_,
							const vector<compute_kernel_arg>& args,
							const vector<const compute_fence*>& wait_fences_,
							const vector<compute_fence*>& signal_fences_,
							const char* debug_label,
							kernel_completion_handler_f&& completion_handler) const {
	// no cooperative support yet
	if (is_cooperative) {
		log_error("cooperative kernel execution is not supported for Vulkan");
		return;
	}
	
	// find entry for queue device
	const auto kernel_iter = get_kernel(cqueue);
	if (kernel_iter == kernels.cend()) {
		log_error("no kernel for this compute queue/device exists!");
		return;
	}
	
	const auto& vk_dev = kernel_iter->first.get();
	const auto& vk_queue = (const vulkan_queue&)cqueue;
	const auto& vk_ctx = *(vulkan_compute*)vk_dev.context;
	
	// check work size
	const uint3 block_dim = check_local_work_size(kernel_iter->second, local_work_size_);
	if (kernel_iter->second.info->has_valid_required_local_size() &&
		(kernel_iter->second.info->required_local_size != local_work_size_.maxed(1u)).any()) {
		log_error("kernel $ has fixed compiled required local size of $, it may not be executed with a different local size of $",
				  kernel_iter->second.info->name, kernel_iter->second.info->required_local_size, local_work_size_);
		return;
	}
	
	const uint3 grid_dim_overflow {
		global_work_size.x > 0 ? std::min(uint32_t(global_work_size.x % block_dim.x), 1u) : 0u,
		global_work_size.y > 0 ? std::min(uint32_t(global_work_size.y % block_dim.y), 1u) : 0u,
		global_work_size.z > 0 ? std::min(uint32_t(global_work_size.z % block_dim.z), 1u) : 0u
	};
	uint3 grid_dim { (global_work_size / block_dim) + grid_dim_overflow };
	grid_dim.max(1u);
	
	// create command buffer ("encoder") for this kernel execution
	const vector<const vulkan_kernel_entry*> shader_entries {
		&kernel_iter->second
	};
	bool encoder_success = false;
	auto encoder = create_encoder(cqueue, external_cmd_buffer,
								  get_pipeline_spec(vk_dev, kernel_iter->second, block_dim),
								  kernel_iter->second.pipeline_layout,
								  shader_entries, debug_label, encoder_success);
	if (!encoder_success) {
		log_error("failed to create vulkan encoder / command buffer for kernel \"$\"", kernel_iter->second.info->name);
		return;