Method execute

src/device/vulkan/vulkan_function.cpp:274–515

}

void vulkan_function::execute(const device_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 std::vector<device_function_arg>& args,
							const std::vector<const device_fence*>& wait_fences_,
							const std::vector<device_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 function_iter = get_function(cqueue);
	if (function_iter == functions.cend()) {
		log_error("no function \"$\" for this compute queue/device exists!", function_name);
		return;
	}
	
	const auto& vk_dev = *function_iter->first;
	const auto& vk_queue = (const vulkan_queue&)cqueue;
	
	// check work size
	const uint3 block_dim = check_local_work_size(*function_iter->second, local_work_size_);
	if (function_iter->second->info->has_valid_required_local_size() &&
		(function_iter->second->info->required_local_size != local_work_size_.maxed(1u)).any()) {
		log_error("function $ has fixed compiled required local size of $, it may not be executed with a different local size of $",
				  function_iter->second->info->name, function_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 function execution
	const std::vector<const vulkan_function_entry*> shader_entries {
		function_iter->second.get()
	};
	bool encoder_success = false;
	auto encoder = create_encoder(cqueue, external_cmd_buffer,
								  get_pipeline_spec(vk_dev, *function_iter->second, block_dim, {} /* use default or program defined */),
								  function_iter->second->pipeline_layout,
								  shader_entries, debug_label, encoder_success);
	if (!encoder_success) {
		log_error("failed to create Vulkan encoder / command buffer for function \"$\"", function_iter->second->info->name);
		return;
	}