AI coded support for VK_EXT_host_image_copy host-pointer

Also added a codex skill file for validating Vulkan extensions.

Author: per-mathisen-arm

.codex/skills/validate_extension/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: validate_extension
+description: Validate the implementation and support in lavatube for a given Vulkan extension
+metadata:
+  short-description: Validate lavatube's support for a Vulkan extension
+---
+
+1. Check that we were told which Vulkan extension we are supposed to check. If this was not specified, ask.
+2. If you are not familiar with the extension, download the extension text from
+   `https://docs.vulkan.org/refpages/latest/refpages/source/<extension name>.html` and read it.
+3. For each new Vulkan command defined in the given extension, look for its generated implementation named
+   `trace_<name>` in `generated/write_auto.cpp`. Review it for errors, then compare it to the corresponding
+   read function named `retrace_<name>` in `generated/read_auto.cpp`. Verify that the serialized output is
+   likely to be read back in correctly. If not found in generated code, they may have been hardcoded in code
+   in the `src` directory instead.
+4. For each new Vulkan structure defined in the given extension, look for its generated implementation named
+   `write_<name>` in `generated/struct_write_auto.cpp`. Review it for errors, then compare it to the
+   corresponding read function named `read_<name>` in `generated/struct_read_auto.cpp`. Verify that the
+   serialized output is likely to be read back in correctly. If not found in generated code, they may have
+   been hardcoded in the `src/hardcode_*.cpp` files instead.
+5. Check if any new object types are defined in the given extension. If so, look at the Vulkan creation
+   command for the object type, and see if there is any metadata there we should be tracking. If so, that
+   should be in `src/lavatube.h` under its corresponding `trackable` child class. The trackable class is
+   typically named the same as the object type but in all lower case and its `vk` prefix replaced with
+   `tracked`.
+6. Check if the extension has been promoted to core (e.g. "Promotion to Vulkan 1.3"). If it has been
+   promoted, and we have any hardcoded functions, check if these also have core equivalents (ie function
+   name without the extension suffix). Warn if these are missing.

CMakeLists.txt

@@ -592,3 +592,4 @@ layer_test(pipeline_executable_properties pipeline_executable_properties)
 #layer_test(cooperative_matrix cooperative_matrix)
 layer_test(extended_dynamic_state3 extended_dynamic_state3)
 #layer_test(push_descriptor)
+layer_test(host_image_copy host_image_copy)

scripts/util.py

@@ -515,7 +515,20 @@ def print_load(self, name, owner): # called for each parameter
 			z.do('%s = reader.read_uint32_t();' % self.name)
 			z.do('if (%s == LAVATUBE_VIRTUAL_QUEUE) %s = selected_queue_family_index;' % (self.name, self.name))
 			if not is_root: z.do('%s = %s;' % (varname, self.name))
-		elif (self.name == 'ppData' and self.funcname in ['vkMapMemory', 'vkMapMemory2KHR', 'vkMapMemory2']) or self.name == 'pHostPointer':
+		elif self.name == 'pHostPointer':
+			if self.funcname in ['VkMemoryToImageCopy', 'VkImageToMemoryCopy']:
+				tmp_uuint64t = z.tmp('uint64_t')
+				z.do('%s = reader.read_uint64_t();' % tmp_uuint64t)
+				z.do('if (%s > 0)' % tmp_uuint64t)
+				z.brace_begin()
+				tmp_uuint8t_ptr = z.tmpmem('uint8_t', tmp_uuint64t)
+				z.do('reader.read_array(%s, %s);' % (tmp_uuint8t_ptr, tmp_uuint64t))
+				z.do('%s = %s;' % (varname, tmp_uuint8t_ptr))
+				z.brace_end()
+				z.do('else %s = nullptr;' % varname)
+			else:
+				z.decl('%s%s%s' % (self.mod, self.type, self.param_ptrstr), self.name)
+		elif (self.name == 'ppData' and self.funcname in ['vkMapMemory', 'vkMapMemory2KHR', 'vkMapMemory2']):
 			z.decl('%s%s%s' % (self.mod, self.type, self.param_ptrstr), self.name)
 		elif self.name == 'pfnUserCallback' and self.funcname == 'VkDebugUtilsMessengerCreateInfoEXT':
 			z.do('%s = messenger_callback; // hijacking this pointer with our own callback function' % varname)
@@ -834,10 +847,24 @@ def print_save(self, name, owner, postprocess = False): # called for each parame
 			z.do('initialDataSize = 0;')
 		elif (self.name == 'pInitialData' and self.funcname == 'VkPipelineCacheCreateInfo'):
 			z.do('assert(false); // pInitialData')
-		elif (self.name == 'ppData' and self.funcname in ['vkMapMemory', 'vkMapMemory2KHR', 'vkMapMemory2']) or self.name == 'pHostPointer':
+		elif self.name == 'pHostPointer':
+			if self.funcname in ['VkMemoryToImageCopy', 'VkImageToMemoryCopy']:
+				z.decl('uint64_t', 'host_copy_size')
+				z.do('host_copy_size = host_image_copy_size(writer.host_copy_format, &sptr->imageSubresource, &sptr->imageExtent, sptr->memoryRowLength, sptr->memoryImageHeight);')
+				z.do('writer.write_uint64_t(host_copy_size);')
+				z.do('if (host_copy_size > 0 && sptr->pHostPointer) writer.write_array(reinterpret_cast<const char*>(sptr->pHostPointer), host_copy_size);')
+			else:
+				pass
+		elif (self.name == 'ppData' and self.funcname in ['vkMapMemory', 'vkMapMemory2KHR', 'vkMapMemory2']):
 			pass
 		elif self.structure:
-			self.print_struct(self.type, varname, owner, size=self.length)
+			if self.name == 'pRegions' and self.type in ['VkMemoryToImageCopy', 'VkImageToMemoryCopy'] and self.funcname in ['VkCopyMemoryToImageInfo', 'VkCopyImageToMemoryInfo']:
+				z.decl('VkFormat', 'prev_host_copy_format', custom='writer.host_copy_format')
+				z.do('writer.host_copy_format = image_data ? image_data->format : VK_FORMAT_UNDEFINED;')
+				self.print_struct(self.type, varname, owner, size=self.length)
+				z.do('writer.host_copy_format = prev_host_copy_format;')
+			else:
+				self.print_struct(self.type, varname, owner, size=self.length)
 		elif self.funcname in ['VkDebugMarkerObjectNameInfoEXT', 'VkDebugMarkerObjectTagInfoEXT', 'vkDebugReportMessageEXT'] and self.name == 'object':
 			z.do('auto* object_data = debug_object_trackable(writer.parent->records, %sobjectType, %s);' % (owner, varname))
 			z.do('writer.write_handle(object_data);')

src/util.cpp

@@ -2,6 +2,7 @@
 #include "jsoncpp/json/writer.h"
 
 #include <string.h>
+#include <vulkan/vulkan_format_traits.hpp>
 #include <spirv/unified1/spirv.h>
 
 #if defined(_GNU_SOURCE) || defined(__BIONIC__)
@@ -50,6 +51,58 @@ int get_env_int(const char* name, int v)
 	return v;
 }
 
+static VkFormat host_image_copy_plane_format(VkFormat format, VkImageAspectFlags aspect)
+{
+	if ((aspect & (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT)) == 0)
+	{
+		return format;
+	}
+
+	uint32_t plane = 0;
+	if (aspect & VK_IMAGE_ASPECT_PLANE_1_BIT) plane = 1;
+	else if (aspect & VK_IMAGE_ASPECT_PLANE_2_BIT) plane = 2;
+	const auto plane_format = VULKAN_HPP_NAMESPACE::planeCompatibleFormat(static_cast<VULKAN_HPP_NAMESPACE::Format>(format), plane);
+	if (plane_format == VULKAN_HPP_NAMESPACE::Format::eUndefined)
+	{
+		return format;
+	}
+	return static_cast<VkFormat>(plane_format);
+}
+
+uint64_t host_image_copy_size(VkFormat format, const VkImageSubresourceLayers* subresource, const VkExtent3D* extent, uint32_t memory_row_length, uint32_t memory_image_height)
+{
+	if (!subresource || !extent || format == VK_FORMAT_UNDEFINED)
+	{
+		return 0;
+	}
+
+	const VkFormat plane_format = host_image_copy_plane_format(format, subresource->aspectMask);
+	const auto vk_format = static_cast<VULKAN_HPP_NAMESPACE::Format>(plane_format);
+	const auto block_extent = VULKAN_HPP_NAMESPACE::blockExtent(vk_format);
+	const uint32_t block_width = block_extent[0] ? block_extent[0] : 1;
+	const uint32_t block_height = block_extent[1] ? block_extent[1] : 1;
+	const uint32_t block_depth = block_extent[2] ? block_extent[2] : 1;
+	const uint32_t block_size = VULKAN_HPP_NAMESPACE::blockSize(vk_format);
+	if (block_size == 0)
+	{
+		WLOG("host_image_copy_size: unsupported format %u", static_cast<uint32_t>(plane_format));
+		return 0;
+	}
+
+	const uint32_t row_length = memory_row_length ? memory_row_length : extent->width;
+	const uint32_t image_height = memory_image_height ? memory_image_height : extent->height;
+	const uint32_t depth = extent->depth ? extent->depth : 1;
+	if (row_length == 0 || image_height == 0 || depth == 0 || subresource->layerCount == 0)
+	{
+		return 0;
+	}
+
+	const uint64_t row_blocks = (row_length + block_width - 1) / block_width;
+	const uint64_t height_blocks = (image_height + block_height - 1) / block_height;
+	const uint64_t depth_blocks = (depth + block_depth - 1) / block_depth;
+	return row_blocks * height_blocks * depth_blocks * static_cast<uint64_t>(subresource->layerCount) * block_size;
+}
+
 int get_env_bool(const char* name, int v)
 {
 	const char* tmpstr = getenv(name);
@@ -375,7 +428,6 @@ const char* pretty_print_VkObjectType(VkObjectType val)
 	case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: return "BufferCollectionFUCHSIA";
 	case VK_OBJECT_TYPE_MICROMAP_EXT: return "Micromap";
 	case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: return "OpticalFlowSessionNV";
-	case VK_OBJECT_TYPE_MAX_ENUM: assert(false); return "Error";
 	case VK_OBJECT_TYPE_VIDEO_SESSION_KHR: return "VideoSession";
 	case VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: return "VideoSessionParameters";
 	case VK_OBJECT_TYPE_SHADER_EXT: return "Shader";
@@ -386,6 +438,7 @@ const char* pretty_print_VkObjectType(VkObjectType val)
 	case VK_OBJECT_TYPE_TENSOR_VIEW_ARM: return "Tensor view";
 	case VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: return "Data graph pipeline session";
 	case VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: return "External compute queue";
+	case VK_OBJECT_TYPE_MAX_ENUM: assert(false); return "Error";
 	}
 	return "Error";
 }

src/util.h

@@ -169,6 +169,7 @@ static inline std::string version_to_string(uint32_t v) { return _to_string(VK_V
 const char* errorString(const VkResult errorCode);
 
 void check_retval(VkResult stored_retval, VkResult retval);
+uint64_t host_image_copy_size(VkFormat format, const VkImageSubresourceLayers* subresource, const VkExtent3D* extent, uint32_t memory_row_length, uint32_t memory_image_height);
 
 static inline bool is_blackhole_mode() { return p__blackhole; }
 static inline int selected_gpu() { return p__gpu; }

src/write.h

@@ -162,6 +162,7 @@ class lava_file_writer : public file_writer
 	VkDevice device = VK_NULL_HANDLE;
 	VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
 	VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
+	VkFormat host_copy_format = VK_FORMAT_UNDEFINED;
 
 	inline void write_api_command(uint16_t id);