Function create_kernel_entry_descriptor_buffer

compute/vulkan/vulkan_program.cpp:246–328

}

static bool create_kernel_entry_descriptor_buffer(vulkan_kernel::vulkan_kernel_entry& entry,
												  const compute_device& dev,
												  const VkShaderStageFlagBits stage,
												  const string& func_name,
												  const llvm_toolchain::function_info& info) {
	const auto& vk_dev = (const vulkan_device&)dev;
	auto& vk_ctx = *(vulkan_compute*)vk_dev.context;
	const auto dev_queue = vk_ctx.get_device_default_queue(vk_dev);
	assert(dev_queue != nullptr);
	
	if (!has_flag<llvm_toolchain::FUNCTION_FLAGS::USES_VULKAN_DESCRIPTOR_BUFFER>(info.flags)) {
		log_error("can't use a function that has not been built with descriptor buffer support with descriptor buffers: in function $", func_name);
		return false;
	}
	
	auto layout = vulkan_program::build_descriptor_set_layout(dev, func_name, info, stage);
	if (!layout) {
		return false;
	}
	entry.desc_set_layout = layout->desc_set_layout;
	entry.constant_buffer_info = std::move(layout->constant_buffer_info);
	
	if (!layout->bindings.empty()) {
		// query required buffer size + ensure good alignment
		entry.desc_buffer.layout_size_in_bytes = 0;
		vk_ctx.vulkan_get_descriptor_set_layout_size(vk_dev.device, entry.desc_set_layout, &entry.desc_buffer.layout_size_in_bytes);
		entry.desc_buffer.layout_size_in_bytes = const_math::round_next_multiple(entry.desc_buffer.layout_size_in_bytes,
																				 uint64_t(max(256u, vk_dev.descriptor_buffer_offset_alignment)));
		
		// query offset for each binding/argument
		entry.desc_buffer.argument_offsets.reserve(layout->bindings.size());
		for (const auto& binding : layout->bindings) {
			VkDeviceSize offset = 0;
			vk_ctx.vulkan_get_descriptor_set_layout_binding_offset(vk_dev.device, entry.desc_set_layout, binding.binding, &offset);
			entry.desc_buffer.argument_offsets.emplace_back(offset);
		}
		
		// allocate descriptor buffers
		array<vulkan_descriptor_buffer_container::resource_type, vulkan_descriptor_buffer_container::descriptor_count> desc_buffers;
		for (uint32_t buf_idx = 0; buf_idx < vulkan_descriptor_buffer_container::descriptor_count; ++buf_idx) {
			// alloc with Vulkan flags: need host-visible/host-coherent and descriptor buffer usage flags
			desc_buffers[buf_idx].first = vk_ctx.create_buffer(*dev_queue, entry.desc_buffer.layout_size_in_bytes,
															   // NOTE: read-only on the device side (until writable argument buffers are implemented)
															   COMPUTE_MEMORY_FLAG::READ |
															   COMPUTE_MEMORY_FLAG::HOST_READ_WRITE |
															   COMPUTE_MEMORY_FLAG::VULKAN_HOST_COHERENT |
															   COMPUTE_MEMORY_FLAG::VULKAN_DESCRIPTOR_BUFFER);
			desc_buffers[buf_idx].first->set_debug_label("desc_buf:" + func_name + "#" + to_string(buf_idx));
			auto mapped_host_ptr = desc_buffers[buf_idx].first->map(*dev_queue, (COMPUTE_MEMORY_MAP_FLAG::WRITE_INVALIDATE |
																				 COMPUTE_MEMORY_MAP_FLAG::BLOCK));
			desc_buffers[buf_idx].second = { (uint8_t*)mapped_host_ptr, entry.desc_buffer.layout_size_in_bytes };
		}
		entry.desc_buffer.desc_buffer_container = make_unique<vulkan_descriptor_buffer_container>(std::move(desc_buffers));
		
		if (!allocate_constant_buffers(entry, dev, func_name, *layout)) {
			return false;
		}
	}