Method vulkan_program

src/device/vulkan/vulkan_program.cpp:345–489

}

vulkan_program::vulkan_program(program_map_type&& programs_) :
device_program(retrieve_unique_function_names(programs_)), programs(std::move(programs_)) {
	if (programs.empty()) {
		return;
	}
	
	// create all functions of all device programs
	// note that this essentially reshuffles the program "device -> functions" data to "functions -> devices"
	functions.reserve(function_names.size());
	for (const auto& func_name : function_names) {
		vulkan_function::function_map_type function_map;
		for (auto&& prog : programs) {
			if (!prog.second.valid) continue;
			
			for (const auto& info : prog.second.functions) {
				if (info.name == func_name) {
					if (should_ignore_function_for_device(*prog.first, info)) {
						continue;
					}
					
					auto entry = std::make_shared<vulkan_function_entry>();
					entry->info = &info;
					
					auto& prog_entry = prog.second;
					const auto dev = prog.first;
					const auto& vk_dev = (const vulkan_device&)*dev;
					
					const VkShaderStageFlagBits stage = (info.type == FUNCTION_TYPE::VERTEX ? VK_SHADER_STAGE_VERTEX_BIT :
														 info.type == FUNCTION_TYPE::FRAGMENT ? VK_SHADER_STAGE_FRAGMENT_BIT :
														 VK_SHADER_STAGE_COMPUTE_BIT /* should notice anything else earlier */);
					
					if (!info.has_valid_required_local_size()) {
						entry->max_local_size = vk_dev.max_local_size;
						
						// always assume that we can execute this with the max possible work-group size,
						// i.e. use this as the initial default
						entry->max_total_local_size = vk_dev.max_total_local_size;
					} else {
						// a required local size/dim is specified -> use it
						entry->max_local_size = info.required_local_size;
						entry->max_total_local_size = info.required_local_size.extent();
					}
					
					if (info.has_valid_required_simd_width()) {
						entry->required_simd_width = info.required_simd_width;
					}
					
					// TODO: make sure that _all_ of this is synchronized
					if (!create_function_entry_descriptor_buffer(*entry, *dev, stage, func_name, info)) {
						continue;
					}
					
					// find SPIR-V module index for this function
					const auto mod_iter = prog_entry.func_to_mod_map.find(func_name);
					if (mod_iter == prog_entry.func_to_mod_map.end()) {
						log_error("did not find a module mapping for function \"$\"", func_name);
						continue;
					}