Method create_argument_buffer_internal

src/device/vulkan/vulkan_function.cpp:581–685

}

std::unique_ptr<argument_buffer> vulkan_function::create_argument_buffer_internal(const device_queue& cqueue,
																				  const function_entry& kern_entry,
																				  const toolchain::arg_info& arg floor_unused,
																				  const uint32_t& user_arg_index,
																				  const uint32_t& ll_arg_index,
																				  const MEMORY_FLAG& add_mem_flags,
																				  const bool zero_init) const {
	const auto& vk_dev = (const vulkan_device&)cqueue.get_device();
	const auto& vk_ctx = (const vulkan_context&)*vk_dev.context;
	const auto& vulkan_entry = (const vulkan_function_entry&)kern_entry;
	
	// check if info exists
	const auto& arg_info = vulkan_entry.info->args[ll_arg_index].argument_buffer_info;
	if (!arg_info) {
		log_error("no argument buffer info for arg at index #$", user_arg_index);
		return {};
	}
	
	const auto arg_buf_name = vulkan_entry.info->name + ".arg_buffer@" + std::to_string(user_arg_index);
	
	// argument buffers are implemented as individual descriptor sets inside the parent function/program, stored in descriptor buffers
	// -> grab the descriptor set layout from the parent function that has already created this + allocate a descriptor buffer
	if (vulkan_entry.argument_buffers.empty()) {
		log_error("no argument buffer info in function entry (in $)", vulkan_entry.info->name);
		return {};
	}
	
	// find the argument buffer info index
	uint32_t arg_buf_idx = 0;
	for (uint32_t i = 0, count = uint32_t(vulkan_entry.info->args.size()); i < std::min(ll_arg_index, count); ++i) {
		if (i == ll_arg_index) {
			break;
		}
		if (has_flag<ARG_FLAG::ARGUMENT_BUFFER>(vulkan_entry.info->args[i].flags)) {
			++arg_buf_idx;
		}
	}
	if (arg_buf_idx >= vulkan_entry.argument_buffers.size()) {
		log_error("argument buffer info index is out-of-bounds for function entry (arg #$ in $)",
				  user_arg_index, vulkan_entry.info->name);
		return {};
	}
	const auto& arg_buf_info = vulkan_entry.argument_buffers[arg_buf_idx];
	
	// the argument buffer size is device/driver dependent (can't be statically known)
	// -> query required buffer size + ensure good alignment
	const auto arg_buffer_size = const_math::round_next_multiple(arg_buf_info.layout.layout_size, uint64_t(256));
	
	// query offset for each binding/argument
	std::vector<VkDeviceSize> argument_offsets;
	argument_offsets.reserve(arg_buf_info.layout.bindings.size());
	for (const auto& binding : arg_buf_info.layout.bindings) {
		VkDeviceSize offset = 0;
		vkGetDescriptorSetLayoutBindingOffsetEXT(vk_dev.device, arg_buf_info.layout.desc_set_layout, binding.binding, &offset);
		argument_offsets.emplace_back(offset);
	}
	
	// alloc with Vulkan flags: need host-visible/host-coherent and descriptor buffer usage flags