diff options
26 files changed, 2810 insertions, 525 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index c2b081b5..28be80d3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,6 @@ +cmake_policy(SET CMP0048 NEW) project(gfx-streaming-kit) -cmake_minimum_required(VERSION 3.11) +cmake_minimum_required(VERSION 3.18) option(BUILD_ASAN_WIN32 "Build with ASAN on Windows platform" OFF) @@ -23,8 +24,13 @@ endif() find_package(Threads) include(ExternalProject) + include(GoogleTest) enable_testing() +# Disable test discovery after build. +# By default, `gtest_discover_tests()` adds a post-build step to run the test executables in order to discover the test +# targets. This is problematic in some build environments. (for example: if cross-compiling) +set(CMAKE_GTEST_DISCOVER_TESTS_DISCOVERY_MODE "PRE_TEST") # set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) @@ -57,6 +63,12 @@ if (MSVC) add_compile_definitions(_CRT_NONSTDC_NO_DEPRECATE) endif() +# Macro to easily set the TEST_INCLUDE_FILES properties to point to `test_properties.cmake` +# This macro should be called at the end of any CMakeLists.txt file that defines test targets. +macro("set_test_include_files") +set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES ${CMAKE_SOURCE_DIR}/test_properties.cmake) +endmacro() + # Uncomment for ASAN support # set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer -fsanitize=address") # set (CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address") diff --git a/host-common/CMakeLists.txt b/host-common/CMakeLists.txt index fbd373e3..4ea9eb53 100644 --- a/host-common/CMakeLists.txt +++ b/host-common/CMakeLists.txt @@ -149,4 +149,6 @@ target_link_libraries( gtest_main gmock_main) -gtest_discover_tests(gfxstream-host-common_unittests)
\ No newline at end of file +gtest_discover_tests(gfxstream-host-common_unittests) + +set_test_include_files() diff --git a/host-common/FeatureControlDefHost.h b/host-common/FeatureControlDefHost.h index 72d3c9f5..d769e03d 100644 --- a/host-common/FeatureControlDefHost.h +++ b/host-common/FeatureControlDefHost.h @@ -74,3 +74,4 @@ FEATURE_CONTROL_ITEM(S3tcTextureSupport) FEATURE_CONTROL_ITEM(RgtcTextureSupport) FEATURE_CONTROL_ITEM(VulkanNativeSwapchain) FEATURE_CONTROL_ITEM(VirtioGpuFenceContexts) +FEATURE_CONTROL_ITEM(AsyncComposeSupport) diff --git a/host-common/virtio_gpu.h b/host-common/virtio_gpu.h deleted file mode 100644 index 6600518e..00000000 --- a/host-common/virtio_gpu.h +++ /dev/null @@ -1,375 +0,0 @@ -/* - * Virtio GPU Device - * - * Copyright Red Hat, Inc. 2013-2014 - * - * Authors: - * Dave Airlie <airlied@redhat.com> - * Gerd Hoffmann <kraxel@redhat.com> - * - * This header is BSD licensed so anyone can use the definitions - * to implement compatible drivers/servers: - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of IBM nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF - * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT - * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - */ - -#ifndef VIRTIO_GPU_HW_H -#define VIRTIO_GPU_HW_H - -#include "linux_types.h" - -#define VIRTIO_GPU_F_VIRGL 0 -#define VIRTIO_GPU_F_RESOURCE_BLOB 3 - -enum virtio_gpu_ctrl_type { - VIRTIO_GPU_UNDEFINED = 0, - - /* 2d commands */ - VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100, - VIRTIO_GPU_CMD_RESOURCE_CREATE_2D, - VIRTIO_GPU_CMD_RESOURCE_UNREF, - VIRTIO_GPU_CMD_SET_SCANOUT, - VIRTIO_GPU_CMD_RESOURCE_FLUSH, - VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D, - VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, - VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING, - VIRTIO_GPU_CMD_GET_CAPSET_INFO, - VIRTIO_GPU_CMD_GET_CAPSET, - VIRTIO_GPU_CMD_GET_EDID, - VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID, - VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB, - - /* 3d commands */ - VIRTIO_GPU_CMD_CTX_CREATE = 0x0200, - VIRTIO_GPU_CMD_CTX_DESTROY, - VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE, - VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE, - VIRTIO_GPU_CMD_RESOURCE_CREATE_3D, - VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D, - VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D, - VIRTIO_GPU_CMD_SUBMIT_3D, - VIRTIO_GPU_CMD_RESOURCE_MAP, - VIRTIO_GPU_CMD_RESOURCE_UNMAP, - - /* cursor commands */ - VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300, - VIRTIO_GPU_CMD_MOVE_CURSOR, - - /* success responses */ - VIRTIO_GPU_RESP_OK_NODATA = 0x1100, - VIRTIO_GPU_RESP_OK_DISPLAY_INFO, - VIRTIO_GPU_RESP_OK_CAPSET_INFO, - VIRTIO_GPU_RESP_OK_CAPSET, - VIRTIO_GPU_RESP_OK_EDID, - VIRTIO_GPU_RESP_OK_RESOURCE_UUID, - VIRTIO_GPU_RESP_OK_MAP_INFO, - - /* error responses */ - VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200, - VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY, - VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID, - VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID, - VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID, - VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER, -}; - -#define VIRTIO_GPU_FLAG_FENCE (1 << 0) - -struct virtio_gpu_ctrl_hdr { - uint32_t type; - uint32_t flags; - uint64_t fence_id; - uint32_t ctx_id; - uint32_t padding; -}; - -/* data passed in the cursor vq */ - -struct virtio_gpu_cursor_pos { - uint32_t scanout_id; - uint32_t x; - uint32_t y; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_UPDATE_CURSOR, VIRTIO_GPU_CMD_MOVE_CURSOR */ -struct virtio_gpu_update_cursor { - struct virtio_gpu_ctrl_hdr hdr; - struct virtio_gpu_cursor_pos pos; /* update & move */ - uint32_t resource_id; /* update only */ - uint32_t hot_x; /* update only */ - uint32_t hot_y; /* update only */ - uint32_t padding; -}; - -/* data passed in the control vq, 2d related */ - -struct virtio_gpu_rect { - uint32_t x; - uint32_t y; - uint32_t width; - uint32_t height; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_UNREF */ -struct virtio_gpu_resource_unref { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: create a 2d resource with a format */ -struct virtio_gpu_resource_create_2d { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t format; - uint32_t width; - uint32_t height; -}; - -/* VIRTIO_GPU_CMD_SET_SCANOUT */ -struct virtio_gpu_set_scanout { - struct virtio_gpu_ctrl_hdr hdr; - struct virtio_gpu_rect r; - uint32_t scanout_id; - uint32_t resource_id; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_FLUSH */ -struct virtio_gpu_resource_flush { - struct virtio_gpu_ctrl_hdr hdr; - struct virtio_gpu_rect r; - uint32_t resource_id; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: simple transfer to_host */ -struct virtio_gpu_transfer_to_host_2d { - struct virtio_gpu_ctrl_hdr hdr; - struct virtio_gpu_rect r; - uint64_t offset; - uint32_t resource_id; - uint32_t padding; -}; - -struct virtio_gpu_mem_entry { - uint64_t addr; - uint32_t length; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING */ -struct virtio_gpu_resource_attach_backing { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t nr_entries; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING */ -struct virtio_gpu_resource_detach_backing { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t padding; -}; - -/* VIRTIO_GPU_RESP_OK_DISPLAY_INFO */ -#define VIRTIO_GPU_MAX_SCANOUTS 16 -struct virtio_gpu_resp_display_info { - struct virtio_gpu_ctrl_hdr hdr; - struct virtio_gpu_display_one { - struct virtio_gpu_rect r; - uint32_t enabled; - uint32_t flags; - } pmodes[VIRTIO_GPU_MAX_SCANOUTS]; -}; - -/* data passed in the control vq, 3d related */ - -struct virtio_gpu_box { - uint32_t x, y, z; - uint32_t w, h, d; -}; - -/* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D, VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D */ -struct virtio_gpu_transfer_host_3d { - struct virtio_gpu_ctrl_hdr hdr; - struct virtio_gpu_box box; - uint64_t offset; - uint32_t resource_id; - uint32_t level; - uint32_t stride; - uint32_t layer_stride; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_CREATE_3D */ -#define VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP (1 << 0) -struct virtio_gpu_resource_create_3d { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t target; - uint32_t format; - uint32_t bind; - uint32_t width; - uint32_t height; - uint32_t depth; - uint32_t array_size; - uint32_t last_level; - uint32_t nr_samples; - uint32_t flags; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_CTX_CREATE */ -struct virtio_gpu_ctx_create { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t nlen; - uint32_t padding; - char debug_name[64]; -}; - -/* VIRTIO_GPU_CMD_CTX_DESTROY */ -struct virtio_gpu_ctx_destroy { - struct virtio_gpu_ctrl_hdr hdr; -}; - -/* VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE, VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE */ -struct virtio_gpu_ctx_resource { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_SUBMIT_3D */ -struct virtio_gpu_cmd_submit { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t size; - uint32_t padding; -}; - -#define VIRTIO_GPU_CAPSET_VIRGL 1 -#define VIRTIO_GPU_CAPSET_VIRGL2 2 - -/* VIRTIO_GPU_CMD_GET_CAPSET_INFO */ -struct virtio_gpu_get_capset_info { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t capset_index; - uint32_t padding; -}; - -/* VIRTIO_GPU_RESP_OK_CAPSET_INFO */ -struct virtio_gpu_resp_capset_info { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t capset_id; - uint32_t capset_max_version; - uint32_t capset_max_size; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_GET_CAPSET */ -struct virtio_gpu_get_capset { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t capset_id; - uint32_t capset_version; -}; - -/* VIRTIO_GPU_RESP_OK_CAPSET */ -struct virtio_gpu_resp_capset { - struct virtio_gpu_ctrl_hdr hdr; - uint8_t capset_data[]; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB */ -struct virtio_gpu_resource_create_blob { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; -#define VIRTIO_GPU_BLOB_MEM_GUEST 0x0001 -#define VIRTIO_GPU_BLOB_MEM_HOST3D 0x0002 -#define VIRTIO_GPU_BLOB_MEM_HOST3D_GUEST 0x0003 - -#define VIRTIO_GPU_BLOB_FLAG_USE_MAPPABLE 0x0001 -#define VIRTIO_GPU_BLOB_FLAG_USE_SHAREABLE 0x0002 -#define VIRTIO_GPU_BLOB_FLAG_USE_CROSS_DEVICE 0x0004 - /* zero is invalid blob mem */ - uint32_t blob_mem; - uint32_t blob_flags; - uint32_t nr_entries; - uint64_t blob_id; - uint64_t size; - /* - * sizeof(nr_entries * virtio_gpu_mem_entry) bytes follow - */ -}; - -/* VIRTIO_GPU_CMD_RESOURCE_MAP */ -struct virtio_gpu_resource_map { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t padding; - uint64_t offset; -}; - -/* VIRTIO_GPU_RESP_OK_MAP_INFO */ -#define VIRTIO_GPU_MAP_CACHE_MASK 0x0f -#define VIRTIO_GPU_MAP_CACHE_NONE 0x00 -#define VIRTIO_GPU_MAP_CACHE_CACHED 0x01 -#define VIRTIO_GPU_MAP_CACHE_UNCACHED 0x02 -#define VIRTIO_GPU_MAP_CACHE_WC 0x03 -struct virtio_gpu_resp_map_info { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t map_flags; - uint32_t padding; -}; - -/* VIRTIO_GPU_CMD_RESOURCE_UNMAP */ -struct virtio_gpu_resource_unmap { - struct virtio_gpu_ctrl_hdr hdr; - uint32_t resource_id; - uint32_t padding; -}; - -#define VIRTIO_GPU_EVENT_DISPLAY (1 << 0) - -struct virtio_gpu_config { - uint32_t events_read; - uint32_t events_clear; - uint32_t num_scanouts; - uint32_t num_capsets; -}; - -/* simple formats for fbcon/X use */ -enum virtio_gpu_formats { - VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM = 1, - VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM = 2, - VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM = 3, - VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM = 4, - - VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM = 67, - VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM = 68, - - VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM = 121, - VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM = 134, -}; - -#endif diff --git a/scripts/print_gfx_logs/command_printer.py b/scripts/print_gfx_logs/command_printer.py new file mode 100644 index 00000000..0f051eab --- /dev/null +++ b/scripts/print_gfx_logs/command_printer.py @@ -0,0 +1,123 @@ +import io +import textwrap +from typing import Dict +import vulkan_printer + + +class CommandPrinter: + """This class is responsible for printing the commands found in the minidump file to the terminal.""" + + def __init__(self, opcode: int, original_size: int, data: bytes, stream_idx: int, cmd_idx: int): + self.opcode = opcode + self.original_size = original_size + self.data = io.BytesIO(data) + self.stream_idx = stream_idx + self.cmd_idx = cmd_idx + + def print_cmd(self): + """ + Tries to decode and pretty print the command to the terminal. + Falls back to printing hex data if the command doesn't have a printer. + """ + + # Print out the command name + print("\n{}.{} - {}: ({} bytes)".format(self.stream_idx, self.cmd_idx, self.cmd_name(), self.original_size - 8)) + + pretty_printer = getattr(vulkan_printer, self.cmd_name(), None) + if not pretty_printer: + self.print_raw() + return + + try: + pretty_printer(self, indent=4) + # Check that we processed all the bytes, otherwise there's probably a bug in the pretty printing logic + if self.data.tell() != len(self.data.getbuffer()): + raise BufferError( + "Not all data was decoded. Decoded {} bytes but expected {}".format( + self.data.tell(), len(self.data.getbuffer()))) + except Exception as ex: + print("Error while processing {}: {}".format(self.cmd_name(), repr(ex))) + print("Command raw data:") + self.print_raw() + raise ex + + def cmd_name(self) -> str: + """Returns the command name (e.g.: "OP_vkBeginCommandBuffer", or the opcode as a string if unknown""" + return vulkan_printer.opcodes.get(self.opcode, str(self.opcode)) + + def print_raw(self): + """Prints the command data as a hex bytes, as a fallback if we don't know how to decode it""" + truncated = self.original_size > len(self.data.getbuffer()) + 8 + indent = 8 + hex = ' '.join(["{:02x}".format(x) for x in self.data.getbuffer()]) + if truncated: + hex += " [...]" + lines = textwrap.wrap(hex, width=16 * 3 + indent, initial_indent=' ' * indent, subsequent_indent=' ' * indent) + for l in lines: + print(l) + + def read_int(self, num_bytes: int, signed: bool = False) -> int: + assert num_bytes == 4 or num_bytes == 8 + buf = self.data.read(num_bytes) + if len(buf) != num_bytes: + raise EOFError("Unexpectly reached the end of the buffer") + return int.from_bytes(buf, byteorder='little', signed=signed) + + def write(self, msg: str, indent: int): + """Prints a string at a given indentation level""" + assert type(msg) == str + assert type(indent) == int and indent >= 0 + print(" " * indent + msg, end='') + + def write_int(self, + field_name: str, + num_bytes: int, + indent: int, + signed: bool = False, + value: int = None): + """Reads the next 32 or 64 bytes integer from the data stream and prints it""" + if value is None: + value = self.read_int(num_bytes, signed) + self.write("{}: {}\n".format(field_name, value), indent) + + def write_enum(self, field_name: str, enum: Dict[int, str], indent: int, value: int = None): + """Reads the next 32-byte int from the data stream and prints it as an enum""" + if value is None: + value = self.read_int(4) + self.write("{}: {} ({})\n".format(field_name, enum.get(value, ""), value), indent) + + def write_stype_and_pnext(self, expected_stype: str, indent: int): + """Reads and prints the sType and pNext fields found in many Vulkan structs, while also sanity checking them""" + stype = self.read_int(4) + self.write_enum("sType", vulkan_printer.VkStructureType, indent, value=stype) + if vulkan_printer.VkStructureType.get(stype) != expected_stype: + raise ValueError("Wrong sType while decoding data. Expected: " + expected_stype) + + pnext_size = self.read_int(4) + self.write_int("pNextSize", 4, indent, value=pnext_size) + if pnext_size != 0: + raise NotImplementedError("Decoding structs with pNextSize > 0 not supported") + + def write_struct(self, field_name: str, struct_fn, indent: int): + """Reads and prints a struct, calling `struct_fn` to pretty-print it""" + self.write("{}:\n".format(field_name), indent) + struct_fn(self, indent + 1) + + def write_repeated(self, + count_name: str, + field_name: str, + struct_fn, + indent: int, + pointer_name: str = None): + """ + Reads and prints repeated structs, with a 32-byte count field followed by the struct data. + If pointer_name is not None, reads an additional 64-bit pointer within the repeated block + before reading repeated data. + """ + count = self.read_int(4) + if pointer_name is not None: + self.write_int(pointer_name, 8, indent) + assert count < 1000, "count too large: {}".format(count) # Sanity check that we haven't read garbage data + self.write_int(count_name, 4, indent, value=count) + for i in range(0, count): + self.write_struct("{} #{}".format(field_name, i), struct_fn, indent) diff --git a/scripts/print_gfx_logs/print_gfx_logs.py b/scripts/print_gfx_logs/print_gfx_logs.py new file mode 100644 index 00000000..273863bd --- /dev/null +++ b/scripts/print_gfx_logs/print_gfx_logs.py @@ -0,0 +1,184 @@ +""" +Command line tool to process minidump files and print what was logged by GfxApiLogger. + +For more details see: + +design: go/bstar-gfx-logging +g3doc: http://g3doc/play/g3doc/games/battlestar/kiwivm/graphics-tips.md#gfx-logs +C++: http://source/play-internal/battlestar/aosp/device/generic/vulkan-cereal/base/GfxApiLogger.h + +Usage: + +python3 print_gfx_logs.py <path to minidump file> +""" + +import argparse +import ctypes +import sys +from datetime import datetime +import mmap +import textwrap +import command_printer +from typing import NamedTuple, Optional, List +import traceback + + +class Header(ctypes.Structure): + """The C struct that we use to represent the data in memory + Keep in sync with GfxApiLogger.h + """ + _fields_ = [('signature', ctypes.c_char * 10), + ('version', ctypes.c_uint16), + ('thread_id', ctypes.c_uint32), + ('last_written_time', ctypes.c_uint64), + ('write_index', ctypes.c_uint32), + ('committed_index', ctypes.c_uint32), + ('capture_id', ctypes.c_uint64), + ('data_size', ctypes.c_uint32)] + + +class Command(NamedTuple): + """A single command in the stream""" + opcode: int + original_size: int + data: bytes + + +class Stream(NamedTuple): + """Stream of commands received from the guest""" + pos_in_file: int # Location of this stream in the minidump file, useful for debugging + timestamp: int # Unix timestamp of last command received, in milliseconds + thread_id: int + capture_id: int + commands: List[Command] + error_message: Optional[str] # `None` if there were no errors parsing this stream + + +def read_uint32(buf: bytes, pos: int) -> int: + """Reads a single uint32 from buf at a given position""" + assert pos + 4 <= len(buf) + return int.from_bytes(buf[pos:pos + 4], byteorder='little', signed=False) + + +def process_command(buf: bytes) -> Command: + opcode = read_uint32(buf, 0) + size = read_uint32(buf, 4) + return Command(opcode, size, bytes(buf[8:])) + + +def process_stream(file_bytes: mmap, file_pos: int) -> Stream: + # Read the header + file_bytes.seek(file_pos) + header = Header() + header_bytes = file_bytes.read(ctypes.sizeof(header)) + ctypes.memmove(ctypes.addressof(header), header_bytes, ctypes.sizeof(header)) + + if header.signature != b'GFXAPILOG': + return Stream(file_pos, error_message="Signature doesn't match") + + if header.version != 2: + return Stream(file_pos, error_message=("This script can only process version 2 of the graphics API logs, " + + "but the dump file uses version {} ").format(data.version)) + + # Convert Windows' GetSystemTimeAsFileTime to Unix timestamp + # https://stackoverflow.com/questions/1695288/getting-the-current-time-in-milliseconds-from-the-system-clock-in-windows + timestamp_ms = int(header.last_written_time / 10000 - 11644473600000) + if timestamp_ms <= 0: timestamp_ms = 0 + + # Sanity check the size + if header.data_size > 5_000_000: + return Stream(file_pos, + error_message="data size is larger than 5MB. This likely indicates garbage/corrupted data") + + if header.committed_index >= header.data_size: + return Stream(file_pos, + error_message="index is larger than buffer size. Likely indicates garbage/corrupted data") + + file_bytes.seek(file_pos + ctypes.sizeof(header)) + data = file_bytes.read(header.data_size) + + # Reorder the buffer so that we can read it in a single pass from back to front + buf = data[header.committed_index:] + data[:header.committed_index] + + commands = [] + i = len(buf) + while i >= 4: + i -= 4 + size = read_uint32(buf, i) + if size == 0 or size > i: + # We reached the end of the stream + break + cmd = process_command(buf[i - size:i]) + + commands.append(cmd) + i -= size + + commands.reverse() # so that they're sorted from oldest to most recent + return Stream(file_pos, timestamp_ms, header.thread_id, header.capture_id, commands, None) + + +def process_minidump(dump_file: str) -> List[Stream]: + """ + Extracts a list of commands streams from a minidump file + """ + streams = [] + with open(dump_file, "r+b") as f: + mm = mmap.mmap(f.fileno(), 0) + pos = 0 + while True: + pos = mm.find(b'GFXAPILOG', pos + 1) + if pos == -1: + break + streams.append(process_stream(mm, pos)) + + return streams + + +def main(): + parser = argparse.ArgumentParser(description="""Command line tool to process crash reports and print out the + commands logged by GfxApiLogger""") + parser.add_argument('dump_file', help="Path to minidump file") + + args = parser.parse_args() + streams = process_minidump(args.dump_file) + + streams.sort(key=lambda s: s.timestamp) + + for stream_idx, stream in enumerate(streams): + print(textwrap.dedent(""" + ======================================================= + GfxApiLog command stream #{} at offset {} in dump + - Timestamp: {} + - Thread id: {} + - Capture id: {}""".format(stream_idx, stream.pos_in_file, + datetime.fromtimestamp(stream.timestamp / 1000.0), + stream.thread_id, + stream.capture_id))) + if stream.error_message: + print("Could not decode stream. Error: ", stream.error_message) + continue + + subdecode_size = 0 + for cmd_idx, cmd in enumerate(stream.commands): + cmd_printer = command_printer.CommandPrinter(cmd.opcode, cmd.original_size, cmd.data, stream_idx, cmd_idx) + + try: + cmd_printer.print_cmd() + except: + # Print stack trace and continue + traceback.print_exc(file=sys.stdout) + + if subdecode_size > 0: + subdecode_size -= cmd.original_size + assert subdecode_size >= 0 + if subdecode_size == 0: + print("\n--- end of subdecode ---") + + if cmd_printer.cmd_name() == "OP_vkQueueFlushCommandsGOOGLE": + assert subdecode_size == 0 + subdecode_size = cmd.original_size - 36 + print("\n--- start of subdecode, size = {} bytes ---".format(subdecode_size)) + + +if __name__ == '__main__': + main() diff --git a/scripts/print_gfx_logs/vulkan_printer.py b/scripts/print_gfx_logs/vulkan_printer.py new file mode 100644 index 00000000..bbddce88 --- /dev/null +++ b/scripts/print_gfx_logs/vulkan_printer.py @@ -0,0 +1,2053 @@ +##################################################################################################### +# Pretty-printer functions for Vulkan data structures +# THIS FILE IS AUTO-GENERATED - DO NOT EDIT +# Actually right now it is written by hand - TODO(gregschlom): auto-generate this +##################################################################################################### + +def OP_vkCmdBeginRenderPass(printer, indent: int): + printer.write_struct("pRenderPassBegin", struct_VkRenderPassBeginInfo, indent) + printer.write_enum("contents", VkSubpassContents, indent) + +def OP_vkCmdBindPipeline(printer, indent: int): + printer.write_enum("pipelineBindPoint", VkPipelineBindPoint, indent) + printer.write_int("pipeline", 8, indent) + +def OP_vkCmdCopyBufferToImage(printer, indent: int): + printer.write_int("srcBuffer", 8, indent) + printer.write_int("dstImage", 8, indent) + printer.write_enum("dstImageLayout", VkImageLayout, indent) + printer.write_repeated("regionCount", "pRegions", struct_VkBufferImageCopy, indent) + +def OP_vkCmdPipelineBarrier(printer, indent: int): + printer.write_int("srcStageMask", 4, indent) + printer.write_int("dstStageMask", 4, indent) + printer.write_int("dependencyFlags", 4, indent) + printer.write_repeated("memoryBarrierCount", "pMemoryBarriers", struct_VkMemoryBarrier, indent) + printer.write_repeated("bufferMemoryBarrierCount", "pBufferMemoryBarriers", struct_VkBufferMemoryBarrier, indent) + printer.write_repeated("imageMemoryBarrierCount", "pImageMemoryBarriers", struct_VkImageMemoryBarrier, indent) + + +def struct_VkBufferImageCopy(printer, indent: int): + printer.write_int("bufferOffset", 8, indent) + printer.write_int("bufferRowLength", 4, indent) + printer.write_int("bufferImageHeight", 4, indent) + printer.write_struct("imageSubresource", struct_VkImageSubresourceLayers, indent) + printer.write_struct("imageOffset", struct_VkOffset3D, indent) + printer.write_struct("imageExtent", struct_VkOffset3D, indent) + + +def struct_VkBufferMemoryBarrier(printer, indent: int): + printer.write_stype_and_pnext("VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", indent) + printer.write_int("srcAccessMask", 4, indent) + printer.write_int("dstAccessMask", 4, indent) + printer.write_int("srcQueueFamilyIndex", 4, indent) + printer.write_int("dstQueueFamilyIndex", 4, indent) + printer.write_int("buffer", 8, indent) + printer.write_int("offset", 8, indent) + printer.write_int("size", 8, indent) + +def struct_VkClearValue(printer, indent: int): + printer.write_struct("color", struct_VkClearColorValue, indent) + +def struct_VkClearColorValue(printer, indent: int): + printer.write("0x{:04X}, 0x{:04X}, 0x{:04X}, 0x{:04X}\n".format( + printer.read_int(4), printer.read_int(4), printer.read_int(4), printer.read_int(4)), indent) + +def struct_VkImageMemoryBarrier(printer, indent: int): + printer.write_stype_and_pnext("VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", indent) + printer.write_int("srcAccessMask", 4, indent) + printer.write_int("dstAccessMask", 4, indent) + printer.write_enum("oldLayout", VkImageLayout, indent) + printer.write_enum("newLayout", VkImageLayout, indent) + printer.write_int("srcQueueFamilyIndex", 4, indent) + printer.write_int("dstQueueFamilyIndex", 4, indent) + printer.write_int("image", 8, indent) + printer.write_struct("subresourceRange", struct_VkImageSubresourceRange, indent) + +def struct_VkExtent2D(printer, indent: int): + printer.write_int("width", 4, indent) + printer.write_int("height", 4, indent) + +def struct_VkImageSubresourceLayers(printer, indent: int): + printer.write_int("aspectMask", 4, indent) + printer.write_int("mipLevel", 4, indent) + printer.write_int("baseArrayLayer", 4, indent) + printer.write_int("layerCount", 4, indent) + +def struct_VkImageSubresourceRange(printer, indent: int): + printer.write_int("aspectMask", 4, indent) + printer.write_int("baseMipLevel", 4, indent) + printer.write_int("levelCount", 4, indent) + printer.write_int("baseArrayLayer", 4, indent) + printer.write_int("layerCount", 4, indent) + +def struct_VkMemoryBarrier(printer, indent: int): + printer.write_stype_and_pnext("VK_STRUCTURE_TYPE_MEMORY_BARRIER", indent) + printer.write_int("srcAccessMask", 4, indent) + printer.write_int("dstAccessMask", 4, indent) + +def struct_VkOffset2D(printer, indent: int): + printer.write_int("x", 4, indent, signed=True) + printer.write_int("y", 4, indent, signed=True) + +def struct_VkOffset3D(printer, indent: int): + printer.write("x: {}, y: {}, z: {}\n".format(printer.read_int(4), printer.read_int(4), printer.read_int(4)), indent) + +def struct_VkRect2D(printer, indent: int): + printer.write_struct("offset", struct_VkOffset2D, indent) + printer.write_struct("extent", struct_VkExtent2D, indent) + +def struct_VkRenderPassBeginInfo(printer, indent: int): + printer.write_stype_and_pnext("VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", indent) + printer.write_int("renderPass", 8, indent) + printer.write_int("framebuffer", 8, indent) + printer.write_struct("renderArea", struct_VkRect2D, indent) + printer.write_repeated("clearValueCount", "pClearValues", struct_VkClearValue, indent, + "pClearValuesPtr") +VkImageLayout = { + 0: "VK_IMAGE_LAYOUT_UNDEFINED", + 1: "VK_IMAGE_LAYOUT_GENERAL", + 2: "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL", + 3: "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL", + 4: "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL", + 5: "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL", + 6: "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL", + 7: "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL", + 8: "VK_IMAGE_LAYOUT_PREINITIALIZED", + 1000117000: "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL", + 1000117001: "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL", + 1000241000: "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL", + 1000241001: "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL", + 1000241002: "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL", + 1000241003: "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", + 1000314000: "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL", + 1000314001: "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL", + 1000001002: "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR", + 1000024000: "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR", + 1000024001: "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR", + 1000024002: "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR", + 1000111000: "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR", + 1000218000: "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT", + 1000164003: "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR", + 1000299000: "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR", + 1000299001: "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR", + 1000299002: "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR", +} + +VkPipelineBindPoint = { + 0: "VK_PIPELINE_BIND_POINT_GRAPHICS", + 1: "VK_PIPELINE_BIND_POINT_COMPUTE", + 1000165000: "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR", + 1000369003: "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI", +} + +VkStructureType = { + 0: "VK_STRUCTURE_TYPE_APPLICATION_INFO", + 1: "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", + 2: "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", + 3: "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", + 4: "VK_STRUCTURE_TYPE_SUBMIT_INFO", + 5: "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", + 6: "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", + 7: "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO", + 8: "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", + 9: "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", + 10: "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", + 11: "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", + 12: "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", + 13: "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", + 14: "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", + 15: "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", + 16: "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", + 17: "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", + 18: "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", + 19: "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", + 20: "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", + 21: "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO", + 22: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO", + 23: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", + 24: "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", + 25: "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", + 26: "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", + 27: "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", + 28: "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", + 29: "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", + 30: "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", + 31: "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", + 32: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", + 33: "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", + 34: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", + 35: "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", + 36: "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", + 37: "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", + 38: "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", + 39: "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", + 40: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", + 41: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", + 42: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", + 43: "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", + 44: "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", + 45: "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", + 46: "VK_STRUCTURE_TYPE_MEMORY_BARRIER", + 47: "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO", + 48: "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO", + 1000094000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES", + 1000157000: "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO", + 1000157001: "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO", + 1000083000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES", + 1000127000: "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS", + 1000127001: "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO", + 1000060000: "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO", + 1000060003: "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO", + 1000060004: "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO", + 1000060005: "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO", + 1000060006: "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO", + 1000060013: "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO", + 1000060014: "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO", + 1000070000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES", + 1000070001: "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO", + 1000146000: "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2", + 1000146001: "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2", + 1000146002: "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2", + 1000146003: "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2", + 1000146004: "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2", + 1000059000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2", + 1000059001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2", + 1000059002: "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2", + 1000059003: "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", + 1000059004: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2", + 1000059005: "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2", + 1000059006: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2", + 1000059007: "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2", + 1000059008: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2", + 1000117000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES", + 1000117001: "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO", + 1000117002: "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO", + 1000117003: "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO", + 1000053000: "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO", + 1000053001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES", + 1000053002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES", + 1000120000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES", + 1000145000: "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO", + 1000145001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES", + 1000145002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES", + 1000145003: "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2", + 1000156000: "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", + 1000156001: "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO", + 1000156002: "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO", + 1000156003: "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO", + 1000156004: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES", + 1000156005: "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES", + 1000085000: "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO", + 1000071000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO", + 1000071001: "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES", + 1000071002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO", + 1000071003: "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES", + 1000071004: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES", + 1000072000: "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO", + 1000072001: "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO", + 1000072002: "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO", + 1000112000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO", + 1000112001: "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES", + 1000113000: "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO", + 1000077000: "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO", + 1000076000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO", + 1000076001: "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES", + 1000168000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES", + 1000168001: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT", + 1000063000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES", + 49: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES", + 50: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES", + 51: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES", + 52: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES", + 1000147000: "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO", + 1000109000: "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2", + 1000109001: "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2", + 1000109002: "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2", + 1000109003: "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2", + 1000109004: "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2", + 1000109005: "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO", + 1000109006: "VK_STRUCTURE_TYPE_SUBPASS_END_INFO", + 1000177000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES", + 1000196000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES", + 1000180000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES", + 1000082000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES", + 1000197000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES", + 1000161000: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO", + 1000161001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES", + 1000161002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES", + 1000161003: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO", + 1000161004: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT", + 1000199000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES", + 1000199001: "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE", + 1000221000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES", + 1000246000: "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO", + 1000130000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES", + 1000130001: "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO", + 1000211000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES", + 1000108000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES", + 1000108001: "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO", + 1000108002: "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO", + 1000108003: "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO", + 1000253000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES", + 1000175000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES", + 1000241000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES", + 1000241001: "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT", + 1000241002: "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT", + 1000261000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES", + 1000207000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES", + 1000207001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES", + 1000207002: "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO", + 1000207003: "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO", + 1000207004: "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO", + 1000207005: "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO", + 1000257000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES", + 1000244001: "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO", + 1000257002: "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO", + 1000257003: "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO", + 1000257004: "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO", + 53: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES", + 54: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES", + 1000192000: "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO", + 1000215000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES", + 1000245000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES", + 1000276000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES", + 1000295000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES", + 1000295001: "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO", + 1000295002: "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO", + 1000297000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES", + 1000314000: "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2", + 1000314001: "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2", + 1000314002: "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2", + 1000314003: "VK_STRUCTURE_TYPE_DEPENDENCY_INFO", + 1000314004: "VK_STRUCTURE_TYPE_SUBMIT_INFO_2", + 1000314005: "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO", + 1000314006: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO", + 1000314007: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES", + 1000325000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES", + 1000335000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES", + 1000337000: "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2", + 1000337001: "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2", + 1000337002: "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2", + 1000337003: "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2", + 1000337004: "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2", + 1000337005: "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2", + 1000337006: "VK_STRUCTURE_TYPE_BUFFER_COPY_2", + 1000337007: "VK_STRUCTURE_TYPE_IMAGE_COPY_2", + 1000337008: "VK_STRUCTURE_TYPE_IMAGE_BLIT_2", + 1000337009: "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2", + 1000337010: "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2", + 1000225000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES", + 1000225001: "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO", + 1000225002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES", + 1000138000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES", + 1000138001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES", + 1000138002: "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK", + 1000138003: "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO", + 1000066000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES", + 1000044000: "VK_STRUCTURE_TYPE_RENDERING_INFO", + 1000044001: "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO", + 1000044002: "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO", + 1000044003: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES", + 1000044004: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO", + 1000280000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES", + 1000280001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES", + 1000281001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES", + 1000360000: "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3", + 1000413000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES", + 1000413001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES", + 1000413002: "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS", + 1000413003: "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS", + 1000001000: "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", + 1000001001: "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", + 1000060007: "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR", + 1000060008: "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR", + 1000060009: "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR", + 1000060010: "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR", + 1000060011: "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR", + 1000060012: "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR", + 1000002000: "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR", + 1000002001: "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR", + 1000003000: "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR", + 1000004000: "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR", + 1000005000: "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR", + 1000006000: "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR", + 1000008000: "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR", + 1000009000: "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR", + 1000011000: "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT", + 1000018000: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD", + 1000022000: "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT", + 1000022001: "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT", + 1000022002: "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", + 1000023000: "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR", + 1000023001: "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR", + 1000023002: "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR", + 1000023003: "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR", + 1000023004: "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR", + 1000023005: "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR", + 1000023006: "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR", + 1000023007: "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR", + 1000023008: "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR", + 1000023009: "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR", + 1000023010: "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR", + 1000023011: "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR", + 1000023012: "VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR", + 1000023013: "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR", + 1000023014: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR", + 1000023015: "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR", + 1000023016: "VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR", + 1000024000: "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR", + 1000024001: "VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR", + 1000026000: "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV", + 1000026001: "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV", + 1000026002: "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV", + 1000028000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT", + 1000028001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT", + 1000028002: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT", + 1000029000: "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX", + 1000029001: "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX", + 1000029002: "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX", + 1000030000: "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX", + 1000030001: "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX", + 1000038000: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT", + 1000038001: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT", + 1000038002: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT", + 1000038003: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT", + 1000038004: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT", + 1000038005: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT", + 1000038006: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT", + 1000038007: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT", + 1000038008: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT", + 1000038009: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT", + 1000038010: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT", + 1000038011: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT", + 1000039000: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT", + 1000039001: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT", + 1000039002: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT", + 1000039003: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT", + 1000039004: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT", + 1000039005: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT", + 1000039006: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT", + 1000039007: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT", + 1000039008: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT", + 1000039009: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT", + 1000039010: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT", + 1000039011: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT", + 1000040000: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT", + 1000040001: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT", + 1000040002: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT", + 1000040003: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT", + 1000040004: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT", + 1000040005: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT", + 1000040006: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT", + 1000040007: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT", + 1000041000: "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD", + 1000044006: "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", + 1000044007: "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT", + 1000044008: "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD", + 1000044009: "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX", + 1000049000: "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP", + 1000050000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV", + 1000056000: "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV", + 1000056001: "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV", + 1000057000: "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV", + 1000057001: "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV", + 1000058000: "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV", + 1000061000: "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT", + 1000062000: "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN", + 1000067000: "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT", + 1000067001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT", + 1000073000: "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR", + 1000073001: "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR", + 1000073002: "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR", + 1000073003: "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR", + 1000074000: "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR", + 1000074001: "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR", + 1000074002: "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR", + 1000075000: "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR", + 1000078000: "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", + 1000078001: "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", + 1000078002: "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR", + 1000078003: "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR", + 1000079000: "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR", + 1000079001: "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR", + 1000080000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR", + 1000081000: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT", + 1000081001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT", + 1000081002: "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT", + 1000084000: "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR", + 1000087000: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV", + 1000090000: "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT", + 1000091000: "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT", + 1000091001: "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT", + 1000091002: "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT", + 1000091003: "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT", + 1000092000: "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE", + 1000097000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX", + 1000098000: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV", + 1000099000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT", + 1000099001: "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT", + 1000101000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT", + 1000101001: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT", + 1000102000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT", + 1000102001: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT", + 1000105000: "VK_STRUCTURE_TYPE_HDR_METADATA_EXT", + 1000111000: "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR", + 1000114000: "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR", + 1000114001: "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR", + 1000114002: "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR", + 1000115000: "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR", + 1000115001: "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR", + 1000116000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR", + 1000116001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR", + 1000116002: "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR", + 1000116003: "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR", + 1000116004: "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR", + 1000116005: "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR", + 1000116006: "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR", + 1000119000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR", + 1000119001: "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR", + 1000119002: "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR", + 1000121000: "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR", + 1000121001: "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR", + 1000121002: "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR", + 1000121003: "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR", + 1000121004: "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR", + 1000122000: "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK", + 1000123000: "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK", + 1000128000: "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT", + 1000128001: "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT", + 1000128002: "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT", + 1000128003: "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT", + 1000128004: "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT", + 1000129000: "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID", + 1000129001: "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID", + 1000129002: "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID", + 1000129003: "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", + 1000129004: "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", + 1000129005: "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID", + 1000129006: "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID", + 1000143000: "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", + 1000143001: "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT", + 1000143002: "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT", + 1000143003: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT", + 1000143004: "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT", + 1000148000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT", + 1000148001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT", + 1000148002: "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT", + 1000149000: "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV", + 1000150007: "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR", + 1000150000: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR", + 1000150002: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR", + 1000150003: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR", + 1000150004: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR", + 1000150005: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR", + 1000150006: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR", + 1000150009: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR", + 1000150010: "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR", + 1000150011: "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR", + 1000150012: "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR", + 1000150013: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR", + 1000150014: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR", + 1000150017: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR", + 1000150020: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR", + 1000347000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR", + 1000347001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR", + 1000150015: "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR", + 1000150016: "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR", + 1000150018: "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR", + 1000348013: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR", + 1000152000: "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV", + 1000154000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV", + 1000154001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV", + 1000158000: "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT", + 1000158002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT", + 1000158003: "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT", + 1000158004: "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT", + 1000158005: "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT", + 1000158006: "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT", + 1000160000: "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT", + 1000160001: "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT", + 1000163000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR", + 1000163001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR", + 1000164000: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV", + 1000164001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV", + 1000164002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV", + 1000164005: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV", + 1000165000: "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV", + 1000165001: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV", + 1000165003: "VK_STRUCTURE_TYPE_GEOMETRY_NV", + 1000165004: "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV", + 1000165005: "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV", + 1000165006: "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV", + 1000165007: "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV", + 1000165008: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV", + 1000165009: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV", + 1000165011: "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV", + 1000165012: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV", + 1000166000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV", + 1000166001: "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV", + 1000170000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT", + 1000170001: "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT", + 1000178000: "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT", + 1000178001: "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT", + 1000178002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT", + 1000181000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR", + 1000183000: "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD", + 1000184000: "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT", + 1000185000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD", + 1000187000: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT", + 1000187001: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT", + 1000187002: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT", + 1000187003: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT", + 1000187004: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT", + 1000187005: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT", + 1000187006: "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT", + 1000174000: "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR", + 1000388000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR", + 1000388001: "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR", + 1000189000: "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD", + 1000190000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT", + 1000190001: "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT", + 1000190002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT", + 1000191000: "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP", + 1000201000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV", + 1000202000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV", + 1000202001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV", + 1000203000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV", + 1000204000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV", + 1000205000: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV", + 1000205002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV", + 1000206000: "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV", + 1000206001: "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV", + 1000209000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL", + 1000210000: "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL", + 1000210001: "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL", + 1000210002: "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL", + 1000210003: "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL", + 1000210004: "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL", + 1000210005: "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL", + 1000212000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT", + 1000213000: "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD", + 1000213001: "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD", + 1000214000: "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA", + 1000217000: "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT", + 1000218000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT", + 1000218001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT", + 1000218002: "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT", + 1000226000: "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", + 1000226001: "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR", + 1000226002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR", + 1000226003: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR", + 1000226004: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR", + 1000227000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD", + 1000229000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD", + 1000234000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT", + 1000237000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT", + 1000238000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT", + 1000238001: "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT", + 1000239000: "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR", + 1000240000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV", + 1000244000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT", + 1000244002: "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT", + 1000247000: "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT", + 1000248000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR", + 1000249000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV", + 1000249001: "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV", + 1000249002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV", + 1000250000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV", + 1000250001: "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV", + 1000250002: "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV", + 1000251000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT", + 1000252000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT", + 1000254000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT", + 1000254001: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT", + 1000254002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT", + 1000255000: "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT", + 1000255002: "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT", + 1000255001: "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT", + 1000256000: "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT", + 1000259000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT", + 1000259001: "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT", + 1000259002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT", + 1000260000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT", + 1000265000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT", + 1000267000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT", + 1000269000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR", + 1000269001: "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR", + 1000269002: "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR", + 1000269003: "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR", + 1000269004: "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR", + 1000269005: "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR", + 1000273000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT", + 1000277000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV", + 1000277001: "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV", + 1000277002: "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV", + 1000277003: "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV", + 1000277004: "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV", + 1000277005: "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV", + 1000277006: "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV", + 1000277007: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV", + 1000278000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV", + 1000278001: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV", + 1000281000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT", + 1000282000: "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM", + 1000282001: "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM", + 1000284000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT", + 1000284001: "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT", + 1000284002: "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT", + 1000286000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT", + 1000286001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT", + 1000287000: "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT", + 1000287001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT", + 1000287002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT", + 1000290000: "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR", + 1000294000: "VK_STRUCTURE_TYPE_PRESENT_ID_KHR", + 1000294001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR", + 1000299000: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR", + 1000299001: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR", + 1000299002: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR", + 1000299003: "VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR", + 1000300000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV", + 1000300001: "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV", + 1000314008: "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV", + 1000314009: "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV", + 1000323000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR", + 1000326000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV", + 1000326001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV", + 1000326002: "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV", + 1000327000: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV", + 1000327001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV", + 1000327002: "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV", + 1000330000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT", + 1000332000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT", + 1000332001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT", + 1000333000: "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM", + 1000336000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR", + 1000340000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT", + 1000342000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM", + 1000344000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT", + 1000346000: "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT", + 1000351000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE", + 1000351002: "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE", + 1000352000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT", + 1000352001: "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT", + 1000352002: "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT", + 1000353000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT", + 1000355000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT", + 1000355001: "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT", + 1000356000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT", + 1000364000: "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA", + 1000364001: "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA", + 1000364002: "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA", + 1000365000: "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA", + 1000365001: "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA", + 1000366000: "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA", + 1000366001: "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA", + 1000366002: "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA", + 1000366003: "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA", + 1000366004: "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA", + 1000366005: "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA", + 1000366006: "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA", + 1000366007: "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA", + 1000366008: "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA", + 1000366009: "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA", + 1000369000: "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI", + 1000369001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI", + 1000369002: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI", + 1000370000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI", + 1000371000: "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV", + 1000371001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV", + 1000377000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT", + 1000378000: "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX", + 1000381000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT", + 1000381001: "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT", + 1000391000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT", + 1000391001: "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT", + 1000392000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT", + 1000392001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT", + 1000411000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT", + 1000411001: "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT", + 1000412000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT", + 1000420000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE", + 1000420001: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE", + 1000420002: "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE", + 1000425000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM", + 1000425001: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM", + 1000425002: "VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM", + 1000430000: "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV", +} + +VkSubpassContents = { + 0: "VK_SUBPASS_CONTENTS_INLINE", + 1: "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS", +} + +opcodes = { + # From http://source/play-internal/battlestar/aosp/device/generic/vulkan-cereal/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.h + 20000: "OP_vkCreateInstance", + 20001: "OP_vkDestroyInstance", + 20002: "OP_vkEnumeratePhysicalDevices", + 20003: "OP_vkGetPhysicalDeviceFeatures", + 20004: "OP_vkGetPhysicalDeviceFormatProperties", + 20005: "OP_vkGetPhysicalDeviceImageFormatProperties", + 20006: "OP_vkGetPhysicalDeviceProperties", + 20007: "OP_vkGetPhysicalDeviceQueueFamilyProperties", + 20008: "OP_vkGetPhysicalDeviceMemoryProperties", + 20009: "OP_vkGetInstanceProcAddr", + 20010: "OP_vkGetDeviceProcAddr", + 20011: "OP_vkCreateDevice", + 20012: "OP_vkDestroyDevice", + 20013: "OP_vkEnumerateInstanceExtensionProperties", + 20014: "OP_vkEnumerateDeviceExtensionProperties", + 20015: "OP_vkEnumerateInstanceLayerProperties", + 20016: "OP_vkEnumerateDeviceLayerProperties", + 20017: "OP_vkGetDeviceQueue", + 20018: "OP_vkQueueSubmit", + 20019: "OP_vkQueueWaitIdle", + 20020: "OP_vkDeviceWaitIdle", + 20021: "OP_vkAllocateMemory", + 20022: "OP_vkFreeMemory", + 20023: "OP_vkMapMemory", + 20024: "OP_vkUnmapMemory", + 20025: "OP_vkFlushMappedMemoryRanges", + 20026: "OP_vkInvalidateMappedMemoryRanges", + 20027: "OP_vkGetDeviceMemoryCommitment", + 20028: "OP_vkBindBufferMemory", + 20029: "OP_vkBindImageMemory", + 20030: "OP_vkGetBufferMemoryRequirements", + 20031: "OP_vkGetImageMemoryRequirements", + 20032: "OP_vkGetImageSparseMemoryRequirements", + 20033: "OP_vkGetPhysicalDeviceSparseImageFormatProperties", + 20034: "OP_vkQueueBindSparse", + 20035: "OP_vkCreateFence", + 20036: "OP_vkDestroyFence", + 20037: "OP_vkResetFences", + 20038: "OP_vkGetFenceStatus", + 20039: "OP_vkWaitForFences", + 20040: "OP_vkCreateSemaphore", + 20041: "OP_vkDestroySemaphore", + 20042: "OP_vkCreateEvent", + 20043: "OP_vkDestroyEvent", + 20044: "OP_vkGetEventStatus", + 20045: "OP_vkSetEvent", + 20046: "OP_vkResetEvent", + 20047: "OP_vkCreateQueryPool", + 20048: "OP_vkDestroyQueryPool", + 20049: "OP_vkGetQueryPoolResults", + 20050: "OP_vkCreateBuffer", + 20051: "OP_vkDestroyBuffer", + 20052: "OP_vkCreateBufferView", + 20053: "OP_vkDestroyBufferView", + 20054: "OP_vkCreateImage", + 20055: "OP_vkDestroyImage", + 20056: "OP_vkGetImageSubresourceLayout", + 20057: "OP_vkCreateImageView", + 20058: "OP_vkDestroyImageView", + 20059: "OP_vkCreateShaderModule", + 20060: "OP_vkDestroyShaderModule", + 20061: "OP_vkCreatePipelineCache", + 20062: "OP_vkDestroyPipelineCache", + 20063: "OP_vkGetPipelineCacheData", + 20064: "OP_vkMergePipelineCaches", + 20065: "OP_vkCreateGraphicsPipelines", + 20066: "OP_vkCreateComputePipelines", + 20067: "OP_vkDestroyPipeline", + 20068: "OP_vkCreatePipelineLayout", + 20069: "OP_vkDestroyPipelineLayout", + 20070: "OP_vkCreateSampler", + 20071: "OP_vkDestroySampler", + 20072: "OP_vkCreateDescriptorSetLayout", + 20073: "OP_vkDestroyDescriptorSetLayout", + 20074: "OP_vkCreateDescriptorPool", + 20075: "OP_vkDestroyDescriptorPool", + 20076: "OP_vkResetDescriptorPool", + 20077: "OP_vkAllocateDescriptorSets", + 20078: "OP_vkFreeDescriptorSets", + 20079: "OP_vkUpdateDescriptorSets", + 20080: "OP_vkCreateFramebuffer", + 20081: "OP_vkDestroyFramebuffer", + 20082: "OP_vkCreateRenderPass", + 20083: "OP_vkDestroyRenderPass", + 20084: "OP_vkGetRenderAreaGranularity", + 20085: "OP_vkCreateCommandPool", + 20086: "OP_vkDestroyCommandPool", + 20087: "OP_vkResetCommandPool", + 20088: "OP_vkAllocateCommandBuffers", + 20089: "OP_vkFreeCommandBuffers", + 20090: "OP_vkBeginCommandBuffer", + 20091: "OP_vkEndCommandBuffer", + 20092: "OP_vkResetCommandBuffer", + 20093: "OP_vkCmdBindPipeline", + 20094: "OP_vkCmdSetViewport", + 20095: "OP_vkCmdSetScissor", + 20096: "OP_vkCmdSetLineWidth", + 20097: "OP_vkCmdSetDepthBias", + 20098: "OP_vkCmdSetBlendConstants", + 20099: "OP_vkCmdSetDepthBounds", + 20100: "OP_vkCmdSetStencilCompareMask", + 20101: "OP_vkCmdSetStencilWriteMask", + 20102: "OP_vkCmdSetStencilReference", + 20103: "OP_vkCmdBindDescriptorSets", + 20104: "OP_vkCmdBindIndexBuffer", + 20105: "OP_vkCmdBindVertexBuffers", + 20106: "OP_vkCmdDraw", + 20107: "OP_vkCmdDrawIndexed", + 20108: "OP_vkCmdDrawIndirect", + 20109: "OP_vkCmdDrawIndexedIndirect", + 20110: "OP_vkCmdDispatch", + 20111: "OP_vkCmdDispatchIndirect", + 20112: "OP_vkCmdCopyBuffer", + 20113: "OP_vkCmdCopyImage", + 20114: "OP_vkCmdBlitImage", + 20115: "OP_vkCmdCopyBufferToImage", + 20116: "OP_vkCmdCopyImageToBuffer", + 20117: "OP_vkCmdUpdateBuffer", + 20118: "OP_vkCmdFillBuffer", + 20119: "OP_vkCmdClearColorImage", + 20120: "OP_vkCmdClearDepthStencilImage", + 20121: "OP_vkCmdClearAttachments", + 20122: "OP_vkCmdResolveImage", + 20123: "OP_vkCmdSetEvent", + 20124: "OP_vkCmdResetEvent", + 20125: "OP_vkCmdWaitEvents", + 20126: "OP_vkCmdPipelineBarrier", + 20127: "OP_vkCmdBeginQuery", + 20128: "OP_vkCmdEndQuery", + 20129: "OP_vkCmdResetQueryPool", + 20130: "OP_vkCmdWriteTimestamp", + 20131: "OP_vkCmdCopyQueryPoolResults", + 20132: "OP_vkCmdPushConstants", + 20133: "OP_vkCmdBeginRenderPass", + 20134: "OP_vkCmdNextSubpass", + 20135: "OP_vkCmdEndRenderPass", + 20136: "OP_vkCmdExecuteCommands", + 20137: "OP_vkEnumerateInstanceVersion", + 20138: "OP_vkBindBufferMemory2", + 20139: "OP_vkBindImageMemory2", + 20140: "OP_vkGetDeviceGroupPeerMemoryFeatures", + 20141: "OP_vkCmdSetDeviceMask", + 20142: "OP_vkCmdDispatchBase", + 20143: "OP_vkEnumeratePhysicalDeviceGroups", + 20144: "OP_vkGetImageMemoryRequirements2", + 20145: "OP_vkGetBufferMemoryRequirements2", + 20146: "OP_vkGetImageSparseMemoryRequirements2", + 20147: "OP_vkGetPhysicalDeviceFeatures2", + 20148: "OP_vkGetPhysicalDeviceProperties2", + 20149: "OP_vkGetPhysicalDeviceFormatProperties2", + 20150: "OP_vkGetPhysicalDeviceImageFormatProperties2", + 20151: "OP_vkGetPhysicalDeviceQueueFamilyProperties2", + 20152: "OP_vkGetPhysicalDeviceMemoryProperties2", + 20153: "OP_vkGetPhysicalDeviceSparseImageFormatProperties2", + 20154: "OP_vkTrimCommandPool", + 20155: "OP_vkGetDeviceQueue2", + 20156: "OP_vkCreateSamplerYcbcrConversion", + 20157: "OP_vkDestroySamplerYcbcrConversion", + 20158: "OP_vkCreateDescriptorUpdateTemplate", + 20159: "OP_vkDestroyDescriptorUpdateTemplate", + 20160: "OP_vkUpdateDescriptorSetWithTemplate", + 20161: "OP_vkGetPhysicalDeviceExternalBufferProperties", + 20162: "OP_vkGetPhysicalDeviceExternalFenceProperties", + 20163: "OP_vkGetPhysicalDeviceExternalSemaphoreProperties", + 20164: "OP_vkGetDescriptorSetLayoutSupport", + 282774587: "OP_vkCmdDrawIndirectCount", + 245204359: "OP_vkCmdDrawIndexedIndirectCount", + 279590827: "OP_vkCreateRenderPass2", + 235222847: "OP_vkCmdBeginRenderPass2", + 244873750: "OP_vkCmdNextSubpass2", + 221297834: "OP_vkCmdEndRenderPass2", + 252097672: "OP_vkResetQueryPool", + 267066974: "OP_vkGetSemaphoreCounterValue", + 224777382: "OP_vkWaitSemaphores", + 271024127: "OP_vkSignalSemaphore", + 222632266: "OP_vkGetBufferDeviceAddress", + 230188231: "OP_vkGetBufferOpaqueCaptureAddress", + 260620079: "OP_vkGetDeviceMemoryOpaqueCaptureAddress", + 20165: "OP_vkDestroySurfaceKHR", + 20166: "OP_vkGetPhysicalDeviceSurfaceSupportKHR", + 20167: "OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR", + 20168: "OP_vkGetPhysicalDeviceSurfaceFormatsKHR", + 20169: "OP_vkGetPhysicalDeviceSurfacePresentModesKHR", + 20170: "OP_vkCreateSwapchainKHR", + 20171: "OP_vkDestroySwapchainKHR", + 20172: "OP_vkGetSwapchainImagesKHR", + 20173: "OP_vkAcquireNextImageKHR", + 20174: "OP_vkQueuePresentKHR", + 20175: "OP_vkGetDeviceGroupPresentCapabilitiesKHR", + 20176: "OP_vkGetDeviceGroupSurfacePresentModesKHR", + 20177: "OP_vkGetPhysicalDevicePresentRectanglesKHR", + 20178: "OP_vkAcquireNextImage2KHR", + 20179: "OP_vkGetPhysicalDeviceDisplayPropertiesKHR", + 20180: "OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR", + 20181: "OP_vkGetDisplayPlaneSupportedDisplaysKHR", + 20182: "OP_vkGetDisplayModePropertiesKHR", + 20183: "OP_vkCreateDisplayModeKHR", + 20184: "OP_vkGetDisplayPlaneCapabilitiesKHR", + 20185: "OP_vkCreateDisplayPlaneSurfaceKHR", + 20186: "OP_vkCreateSharedSwapchainsKHR", + 20187: "OP_vkCreateXlibSurfaceKHR", + 20188: "OP_vkGetPhysicalDeviceXlibPresentationSupportKHR", + 20189: "OP_vkCreateXcbSurfaceKHR", + 20190: "OP_vkGetPhysicalDeviceXcbPresentationSupportKHR", + 20191: "OP_vkCreateWaylandSurfaceKHR", + 20192: "OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR", + 20195: "OP_vkCreateAndroidSurfaceKHR", + 20196: "OP_vkCreateWin32SurfaceKHR", + 20197: "OP_vkGetPhysicalDeviceWin32PresentationSupportKHR", + 20198: "OP_vkGetPhysicalDeviceFeatures2KHR", + 20199: "OP_vkGetPhysicalDeviceProperties2KHR", + 20200: "OP_vkGetPhysicalDeviceFormatProperties2KHR", + 20201: "OP_vkGetPhysicalDeviceImageFormatProperties2KHR", + 20202: "OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR", + 20203: "OP_vkGetPhysicalDeviceMemoryProperties2KHR", + 20204: "OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR", + 20205: "OP_vkGetDeviceGroupPeerMemoryFeaturesKHR", + 20206: "OP_vkCmdSetDeviceMaskKHR", + 20207: "OP_vkCmdDispatchBaseKHR", + 20208: "OP_vkTrimCommandPoolKHR", + 20209: "OP_vkEnumeratePhysicalDeviceGroupsKHR", + 20210: "OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR", + 20211: "OP_vkGetMemoryWin32HandleKHR", + 20212: "OP_vkGetMemoryWin32HandlePropertiesKHR", + 20213: "OP_vkGetMemoryFdKHR", + 20214: "OP_vkGetMemoryFdPropertiesKHR", + 20215: "OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", + 20216: "OP_vkImportSemaphoreWin32HandleKHR", + 20217: "OP_vkGetSemaphoreWin32HandleKHR", + 20218: "OP_vkImportSemaphoreFdKHR", + 20219: "OP_vkGetSemaphoreFdKHR", + 20220: "OP_vkCmdPushDescriptorSetKHR", + 20221: "OP_vkCmdPushDescriptorSetWithTemplateKHR", + 20222: "OP_vkCreateDescriptorUpdateTemplateKHR", + 20223: "OP_vkDestroyDescriptorUpdateTemplateKHR", + 20224: "OP_vkUpdateDescriptorSetWithTemplateKHR", + 20225: "OP_vkCreateRenderPass2KHR", + 20226: "OP_vkCmdBeginRenderPass2KHR", + 20227: "OP_vkCmdNextSubpass2KHR", + 20228: "OP_vkCmdEndRenderPass2KHR", + 20229: "OP_vkGetSwapchainStatusKHR", + 20230: "OP_vkGetPhysicalDeviceExternalFencePropertiesKHR", + 20231: "OP_vkImportFenceWin32HandleKHR", + 20232: "OP_vkGetFenceWin32HandleKHR", + 20233: "OP_vkImportFenceFdKHR", + 20234: "OP_vkGetFenceFdKHR", + 299033148: "OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", + 282029987: "OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", + 238952296: "OP_vkAcquireProfilingLockKHR", + 223904011: "OP_vkReleaseProfilingLockKHR", + 20235: "OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR", + 20236: "OP_vkGetPhysicalDeviceSurfaceFormats2KHR", + 20237: "OP_vkGetPhysicalDeviceDisplayProperties2KHR", + 20238: "OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR", + 20239: "OP_vkGetDisplayModeProperties2KHR", + 20240: "OP_vkGetDisplayPlaneCapabilities2KHR", + 20241: "OP_vkGetImageMemoryRequirements2KHR", + 20242: "OP_vkGetBufferMemoryRequirements2KHR", + 20243: "OP_vkGetImageSparseMemoryRequirements2KHR", + 20244: "OP_vkCreateSamplerYcbcrConversionKHR", + 20245: "OP_vkDestroySamplerYcbcrConversionKHR", + 20246: "OP_vkBindBufferMemory2KHR", + 20247: "OP_vkBindImageMemory2KHR", + 20248: "OP_vkGetDescriptorSetLayoutSupportKHR", + 20249: "OP_vkCmdDrawIndirectCountKHR", + 20250: "OP_vkCmdDrawIndexedIndirectCountKHR", + 229059496: "OP_vkGetSemaphoreCounterValueKHR", + 263904357: "OP_vkWaitSemaphoresKHR", + 269919108: "OP_vkSignalSemaphoreKHR", + 272978593: "OP_vkGetPhysicalDeviceFragmentShadingRatesKHR", + 204060280: "OP_vkCmdSetFragmentShadingRateKHR", + 219261480: "OP_vkGetBufferDeviceAddressKHR", + 285631711: "OP_vkGetBufferOpaqueCaptureAddressKHR", + 294671624: "OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR", + 274342644: "OP_vkCreateDeferredOperationKHR", + 215419514: "OP_vkDestroyDeferredOperationKHR", + 203387076: "OP_vkGetDeferredOperationMaxConcurrencyKHR", + 263822960: "OP_vkGetDeferredOperationResultKHR", + 218492930: "OP_vkDeferredOperationJoinKHR", + 269458798: "OP_vkGetPipelineExecutablePropertiesKHR", + 271191699: "OP_vkGetPipelineExecutableStatisticsKHR", + 274148497: "OP_vkGetPipelineExecutableInternalRepresentationsKHR", + 247893766: "OP_vkCmdCopyBuffer2KHR", + 227008250: "OP_vkCmdCopyImage2KHR", + 248841963: "OP_vkCmdCopyBufferToImage2KHR", + 252249060: "OP_vkCmdCopyImageToBuffer2KHR", + 259838288: "OP_vkCmdBlitImage2KHR", + 254857232: "OP_vkCmdResolveImage2KHR", + 20251: "OP_vkGetSwapchainGrallocUsageANDROID", + 20252: "OP_vkAcquireImageANDROID", + 20253: "OP_vkQueueSignalReleaseImageANDROID", + 20254: "OP_vkCreateDebugReportCallbackEXT", + 20255: "OP_vkDestroyDebugReportCallbackEXT", + 20256: "OP_vkDebugReportMessageEXT", + 20257: "OP_vkDebugMarkerSetObjectTagEXT", + 20258: "OP_vkDebugMarkerSetObjectNameEXT", + 20259: "OP_vkCmdDebugMarkerBeginEXT", + 20260: "OP_vkCmdDebugMarkerEndEXT", + 20261: "OP_vkCmdDebugMarkerInsertEXT", + 267779978: "OP_vkCmdBindTransformFeedbackBuffersEXT", + 294396901: "OP_vkCmdBeginTransformFeedbackEXT", + 272333731: "OP_vkCmdEndTransformFeedbackEXT", + 275810601: "OP_vkCmdBeginQueryIndexedEXT", + 279821337: "OP_vkCmdEndQueryIndexedEXT", + 285235943: "OP_vkCmdDrawIndirectByteCountEXT", + 204379647: "OP_vkGetImageViewHandleNVX", + 210668576: "OP_vkGetImageViewAddressNVX", + 20262: "OP_vkCmdDrawIndirectCountAMD", + 20263: "OP_vkCmdDrawIndexedIndirectCountAMD", + 20264: "OP_vkGetShaderInfoAMD", + 241902685: "OP_vkCreateStreamDescriptorSurfaceGGP", + 20265: "OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV", + 20266: "OP_vkGetMemoryWin32HandleNV", + 20267: "OP_vkCreateViSurfaceNN", + 20268: "OP_vkCmdBeginConditionalRenderingEXT", + 20269: "OP_vkCmdEndConditionalRenderingEXT", + 20279: "OP_vkCmdSetViewportWScalingNV", + 20280: "OP_vkReleaseDisplayEXT", + 20281: "OP_vkAcquireXlibDisplayEXT", + 20282: "OP_vkGetRandROutputDisplayEXT", + 20283: "OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT", + 20284: "OP_vkDisplayPowerControlEXT", + 20285: "OP_vkRegisterDeviceEventEXT", + 20286: "OP_vkRegisterDisplayEventEXT", + 20287: "OP_vkGetSwapchainCounterEXT", + 20288: "OP_vkGetRefreshCycleDurationGOOGLE", + 20289: "OP_vkGetPastPresentationTimingGOOGLE", + 20290: "OP_vkCmdSetDiscardRectangleEXT", + 20291: "OP_vkSetHdrMetadataEXT", + 20292: "OP_vkCreateIOSSurfaceMVK", + 20293: "OP_vkCreateMacOSSurfaceMVK", + 20334: "OP_vkGetMTLDeviceMVK", + 20335: "OP_vkSetMTLTextureMVK", + 20336: "OP_vkGetMTLTextureMVK", + 20337: "OP_vkGetMTLBufferMVK", + 20338: "OP_vkUseIOSurfaceMVK", + 20339: "OP_vkGetIOSurfaceMVK", + 20294: "OP_vkSetDebugUtilsObjectNameEXT", + 20295: "OP_vkSetDebugUtilsObjectTagEXT", + 20296: "OP_vkQueueBeginDebugUtilsLabelEXT", + 20297: "OP_vkQueueEndDebugUtilsLabelEXT", + 20298: "OP_vkQueueInsertDebugUtilsLabelEXT", + 20299: "OP_vkCmdBeginDebugUtilsLabelEXT", + 20300: "OP_vkCmdEndDebugUtilsLabelEXT", + 20301: "OP_vkCmdInsertDebugUtilsLabelEXT", + 20302: "OP_vkCreateDebugUtilsMessengerEXT", + 20303: "OP_vkDestroyDebugUtilsMessengerEXT", + 20304: "OP_vkSubmitDebugUtilsMessageEXT", + 20305: "OP_vkGetAndroidHardwareBufferPropertiesANDROID", + 20306: "OP_vkGetMemoryAndroidHardwareBufferANDROID", + 20307: "OP_vkCmdSetSampleLocationsEXT", + 20308: "OP_vkGetPhysicalDeviceMultisamplePropertiesEXT", + 251301237: "OP_vkGetImageDrmFormatModifierPropertiesEXT", + 20309: "OP_vkCreateValidationCacheEXT", + 20310: "OP_vkDestroyValidationCacheEXT", + 20311: "OP_vkMergeValidationCachesEXT", + 20312: "OP_vkGetValidationCacheDataEXT", + 238618340: "OP_vkCmdBindShadingRateImageNV", + 215295078: "OP_vkCmdSetViewportShadingRatePaletteNV", + 236858637: "OP_vkCmdSetCoarseSampleOrderNV", + 259713020: "OP_vkCreateAccelerationStructureNV", + 252775746: "OP_vkDestroyAccelerationStructureNV", + 220234370: "OP_vkGetAccelerationStructureMemoryRequirementsNV", + 202856743: "OP_vkBindAccelerationStructureMemoryNV", + 269050897: "OP_vkCmdBuildAccelerationStructureNV", + 211075498: "OP_vkCmdCopyAccelerationStructureNV", + 210219912: "OP_vkCmdTraceRaysNV", + 203653638: "OP_vkCreateRayTracingPipelinesNV", + 271962641: "OP_vkGetRayTracingShaderGroupHandlesKHR", + 230045846: "OP_vkGetRayTracingShaderGroupHandlesNV", + 269898134: "OP_vkGetAccelerationStructureHandleNV", + 207954431: "OP_vkCmdWriteAccelerationStructuresPropertiesNV", + 278731610: "OP_vkCompileDeferredNV", + 20313: "OP_vkGetMemoryHostPointerPropertiesEXT", + 20314: "OP_vkCmdWriteBufferMarkerAMD", + 295643221: "OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", + 203583186: "OP_vkGetCalibratedTimestampsEXT", + 207334931: "OP_vkCmdDrawMeshTasksNV", + 274079208: "OP_vkCmdDrawMeshTasksIndirectNV", + 223801967: "OP_vkCmdDrawMeshTasksIndirectCountNV", + 225408194: "OP_vkCmdSetExclusiveScissorNV", + 20315: "OP_vkCmdSetCheckpointNV", + 20316: "OP_vkGetQueueCheckpointDataNV", + 203336121: "OP_vkInitializePerformanceApiINTEL", + 296137321: "OP_vkUninitializePerformanceApiINTEL", + 270016385: "OP_vkCmdSetPerformanceMarkerINTEL", + 261519634: "OP_vkCmdSetPerformanceStreamMarkerINTEL", + 251310287: "OP_vkCmdSetPerformanceOverrideINTEL", + 245737492: "OP_vkAcquirePerformanceConfigurationINTEL", + 252877217: "OP_vkReleasePerformanceConfigurationINTEL", + 294947726: "OP_vkQueueSetPerformanceConfigurationINTEL", + 213620482: "OP_vkGetPerformanceParameterINTEL", + 267533472: "OP_vkSetLocalDimmingAMD", + 261626137: "OP_vkCreateImagePipeSurfaceFUCHSIA", + 254915953: "OP_vkCreateMetalSurfaceEXT", + 224361693: "OP_vkGetBufferDeviceAddressEXT", + 282247593: "OP_vkGetPhysicalDeviceToolPropertiesEXT", + 287711429: "OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", + 292032159: "OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", + 268126279: "OP_vkGetPhysicalDeviceSurfacePresentModes2EXT", + 200946668: "OP_vkAcquireFullScreenExclusiveModeEXT", + 257629142: "OP_vkReleaseFullScreenExclusiveModeEXT", + 206369543: "OP_vkGetDeviceGroupSurfacePresentModes2EXT", + 298411290: "OP_vkCreateHeadlessSurfaceEXT", + 263855692: "OP_vkCmdSetLineStippleEXT", + 242995959: "OP_vkResetQueryPoolEXT", + 266285895: "OP_vkCmdSetCullModeEXT", + 212644406: "OP_vkCmdSetFrontFaceEXT", + 260783979: "OP_vkCmdSetPrimitiveTopologyEXT", + 257105245: "OP_vkCmdSetViewportWithCountEXT", + 204588120: "OP_vkCmdSetScissorWithCountEXT", + 243419921: "OP_vkCmdBindVertexBuffers2EXT", + 233771166: "OP_vkCmdSetDepthTestEnableEXT", + 218663304: "OP_vkCmdSetDepthWriteEnableEXT", + 247761589: "OP_vkCmdSetDepthCompareOpEXT", + 223213519: "OP_vkCmdSetDepthBoundsTestEnableEXT", + 286438749: "OP_vkCmdSetStencilTestEnableEXT", + 277159578: "OP_vkCmdSetStencilOpEXT", + 249047049: "OP_vkGetGeneratedCommandsMemoryRequirementsNV", + 297624330: "OP_vkCmdPreprocessGeneratedCommandsNV", + 234711184: "OP_vkCmdExecuteGeneratedCommandsNV", + 270362239: "OP_vkCmdBindPipelineShaderGroupNV", + 285310710: "OP_vkCreateIndirectCommandsLayoutNV", + 292584135: "OP_vkDestroyIndirectCommandsLayoutNV", + 236374049: "OP_vkCreatePrivateDataSlotEXT", + 208891309: "OP_vkDestroyPrivateDataSlotEXT", + 225259406: "OP_vkSetPrivateDataEXT", + 291399427: "OP_vkGetPrivateDataEXT", + 264649847: "OP_vkCmdSetFragmentShadingRateEnumNV", + 220792403: "OP_vkCreateDirectFBSurfaceEXT", + 285441990: "OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT", + 20318: "OP_vkRegisterImageColorBufferGOOGLE", + 20319: "OP_vkRegisterBufferColorBufferGOOGLE", + 20317: "OP_vkMapMemoryIntoAddressSpaceGOOGLE", + 20320: "OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE", + 20321: "OP_vkBeginCommandBufferAsyncGOOGLE", + 20322: "OP_vkEndCommandBufferAsyncGOOGLE", + 20323: "OP_vkResetCommandBufferAsyncGOOGLE", + 20324: "OP_vkCommandBufferHostSyncGOOGLE", + 20325: "OP_vkCreateImageWithRequirementsGOOGLE", + 20326: "OP_vkCreateBufferWithRequirementsGOOGLE", + 20327: "OP_vkGetMemoryHostAddressInfoGOOGLE", + 20328: "OP_vkFreeMemorySyncGOOGLE", + 20329: "OP_vkQueueHostSyncGOOGLE", + 20330: "OP_vkQueueSubmitAsyncGOOGLE", + 20331: "OP_vkQueueWaitIdleAsyncGOOGLE", + 20332: "OP_vkQueueBindSparseAsyncGOOGLE", + 20333: "OP_vkGetLinearImageLayoutGOOGLE", + 20340: "OP_vkQueueFlushCommandsGOOGLE", + 267932433: "OP_vkQueueCommitDescriptorSetUpdatesGOOGLE", + 213659202: "OP_vkCollectDescriptorPoolIdsGOOGLE", + 243985229: "OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE", + 259403971: "OP_vkCreateAccelerationStructureKHR", + 223971120: "OP_vkDestroyAccelerationStructureKHR", + 272943905: "OP_vkCmdBuildAccelerationStructuresKHR", + 258066143: "OP_vkCmdBuildAccelerationStructuresIndirectKHR", + 241919567: "OP_vkBuildAccelerationStructuresKHR", + 241495016: "OP_vkCopyAccelerationStructureKHR", + 256139578: "OP_vkCopyAccelerationStructureToMemoryKHR", + 261558680: "OP_vkCopyMemoryToAccelerationStructureKHR", + 289745796: "OP_vkWriteAccelerationStructuresPropertiesKHR", + 279460332: "OP_vkCmdCopyAccelerationStructureKHR", + 223539733: "OP_vkCmdCopyAccelerationStructureToMemoryKHR", + 203733963: "OP_vkCmdCopyMemoryToAccelerationStructureKHR", + 223466148: "OP_vkGetAccelerationStructureDeviceAddressKHR", + 271696183: "OP_vkCmdWriteAccelerationStructuresPropertiesKHR", + 266386590: "OP_vkGetDeviceAccelerationStructureCompatibilityKHR", + 219720024: "OP_vkGetAccelerationStructureBuildSizesKHR", + 213680716: "OP_vkCmdTraceRaysKHR", + 247628685: "OP_vkCreateRayTracingPipelinesKHR", + 221334934: "OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", + 211788517: "OP_vkCmdTraceRaysIndirectKHR", + 205271933: "OP_vkGetRayTracingShaderGroupStackSizeKHR", + 260219604: "OP_vkCmdSetRayTracingPipelineStackSizeKHR", + + # From http://source/play-internal/battlestar/aosp/device/generic/vulkan-cereal/stream-servers/renderControl_dec/renderControl_opcodes.h + 10000: "OP_rcGetRendererVersion", + 10001: "OP_rcGetEGLVersion", + 10002: "OP_rcQueryEGLString", + 10003: "OP_rcGetGLString", + 10004: "OP_rcGetNumConfigs", + 10005: "OP_rcGetConfigs", + 10006: "OP_rcChooseConfig", + 10007: "OP_rcGetFBParam", + 10008: "OP_rcCreateContext", + 10009: "OP_rcDestroyContext", + 10010: "OP_rcCreateWindowSurface", + 10011: "OP_rcDestroyWindowSurface", + 10012: "OP_rcCreateColorBuffer", + 10013: "OP_rcOpenColorBuffer", + 10014: "OP_rcCloseColorBuffer", + 10015: "OP_rcSetWindowColorBuffer", + 10016: "OP_rcFlushWindowColorBuffer", + 10017: "OP_rcMakeCurrent", + 10018: "OP_rcFBPost", + 10019: "OP_rcFBSetSwapInterval", + 10020: "OP_rcBindTexture", + 10021: "OP_rcBindRenderbuffer", + 10022: "OP_rcColorBufferCacheFlush", + 10023: "OP_rcReadColorBuffer", + 10024: "OP_rcUpdateColorBuffer", + 10025: "OP_rcOpenColorBuffer2", + 10026: "OP_rcCreateClientImage", + 10027: "OP_rcDestroyClientImage", + 10028: "OP_rcSelectChecksumHelper", + 10029: "OP_rcCreateSyncKHR", + 10030: "OP_rcClientWaitSyncKHR", + 10031: "OP_rcFlushWindowColorBufferAsync", + 10032: "OP_rcDestroySyncKHR", + 10033: "OP_rcSetPuid", + 10034: "OP_rcUpdateColorBufferDMA", + 10035: "OP_rcCreateColorBufferDMA", + 10036: "OP_rcWaitSyncKHR", + 10037: "OP_rcCompose", + 10038: "OP_rcCreateDisplay", + 10039: "OP_rcDestroyDisplay", + 10040: "OP_rcSetDisplayColorBuffer", + 10041: "OP_rcGetDisplayColorBuffer", + 10042: "OP_rcGetColorBufferDisplay", + 10043: "OP_rcGetDisplayPose", + 10044: "OP_rcSetDisplayPose", + 10045: "OP_rcSetColorBufferVulkanMode", + 10046: "OP_rcReadColorBufferYUV", + 10047: "OP_rcIsSyncSignaled", + 10048: "OP_rcCreateColorBufferWithHandle", + 10049: "OP_rcCreateBuffer", + 10050: "OP_rcCloseBuffer", + 10051: "OP_rcSetColorBufferVulkanMode2", + 10052: "OP_rcMapGpaToBufferHandle", + 10053: "OP_rcCreateBuffer2", + 10054: "OP_rcMapGpaToBufferHandle2", + 10055: "OP_rcFlushWindowColorBufferAsyncWithFrameNumber", + 10056: "OP_rcSetTracingForPuid", + 10057: "OP_rcMakeCurrentAsync", + 10058: "OP_rcComposeAsync", + 10059: "OP_rcDestroySyncKHRAsync", + 10060: "OP_rcComposeWithoutPost", + 10061: "OP_rcComposeAsyncWithoutPost", + 10062: "OP_rcCreateDisplayById", + 10063: "OP_rcSetDisplayPoseDpi", + 10064: "OP_rcReadColorBufferDMA", + + # From http://source/android/device/generic/vulkan-cereal/stream-servers/gles1_dec/gles1_opcodes.h + 1024: "OP_glAlphaFunc", + 1025: "OP_glClearColor", + 1026: "OP_glClearDepthf", + 1027: "OP_glClipPlanef", + 1028: "OP_glColor4f", + 1029: "OP_glDepthRangef", + 1030: "OP_glFogf", + 1031: "OP_glFogfv", + 1032: "OP_glFrustumf", + 1033: "OP_glGetClipPlanef", + 1034: "OP_glGetFloatv", + 1035: "OP_glGetLightfv", + 1036: "OP_glGetMaterialfv", + 1037: "OP_glGetTexEnvfv", + 1038: "OP_glGetTexParameterfv", + 1039: "OP_glLightModelf", + 1040: "OP_glLightModelfv", + 1041: "OP_glLightf", + 1042: "OP_glLightfv", + 1043: "OP_glLineWidth", + 1044: "OP_glLoadMatrixf", + 1045: "OP_glMaterialf", + 1046: "OP_glMaterialfv", + 1047: "OP_glMultMatrixf", + 1048: "OP_glMultiTexCoord4f", + 1049: "OP_glNormal3f", + 1050: "OP_glOrthof", + 1051: "OP_glPointParameterf", + 1052: "OP_glPointParameterfv", + 1053: "OP_glPointSize", + 1054: "OP_glPolygonOffset", + 1055: "OP_glRotatef", + 1056: "OP_glScalef", + 1057: "OP_glTexEnvf", + 1058: "OP_glTexEnvfv", + 1059: "OP_glTexParameterf", + 1060: "OP_glTexParameterfv", + 1061: "OP_glTranslatef", + 1062: "OP_glActiveTexture", + 1063: "OP_glAlphaFuncx", + 1064: "OP_glBindBuffer", + 1065: "OP_glBindTexture", + 1066: "OP_glBlendFunc", + 1067: "OP_glBufferData", + 1068: "OP_glBufferSubData", + 1069: "OP_glClear", + 1070: "OP_glClearColorx", + 1071: "OP_glClearDepthx", + 1072: "OP_glClearStencil", + 1073: "OP_glClientActiveTexture", + 1074: "OP_glColor4ub", + 1075: "OP_glColor4x", + 1076: "OP_glColorMask", + 1077: "OP_glColorPointer", + 1078: "OP_glCompressedTexImage2D", + 1079: "OP_glCompressedTexSubImage2D", + 1080: "OP_glCopyTexImage2D", + 1081: "OP_glCopyTexSubImage2D", + 1082: "OP_glCullFace", + 1083: "OP_glDeleteBuffers", + 1084: "OP_glDeleteTextures", + 1085: "OP_glDepthFunc", + 1086: "OP_glDepthMask", + 1087: "OP_glDepthRangex", + 1088: "OP_glDisable", + 1089: "OP_glDisableClientState", + 1090: "OP_glDrawArrays", + 1091: "OP_glDrawElements", + 1092: "OP_glEnable", + 1093: "OP_glEnableClientState", + 1094: "OP_glFinish", + 1095: "OP_glFlush", + 1096: "OP_glFogx", + 1097: "OP_glFogxv", + 1098: "OP_glFrontFace", + 1099: "OP_glFrustumx", + 1100: "OP_glGetBooleanv", + 1101: "OP_glGetBufferParameteriv", + 1102: "OP_glClipPlanex", + 1103: "OP_glGenBuffers", + 1104: "OP_glGenTextures", + 1105: "OP_glGetError", + 1106: "OP_glGetFixedv", + 1107: "OP_glGetIntegerv", + 1108: "OP_glGetLightxv", + 1109: "OP_glGetMaterialxv", + 1110: "OP_glGetPointerv", + 1111: "OP_glGetString", + 1112: "OP_glGetTexEnviv", + 1113: "OP_glGetTexEnvxv", + 1114: "OP_glGetTexParameteriv", + 1115: "OP_glGetTexParameterxv", + 1116: "OP_glHint", + 1117: "OP_glIsBuffer", + 1118: "OP_glIsEnabled", + 1119: "OP_glIsTexture", + 1120: "OP_glLightModelx", + 1121: "OP_glLightModelxv", + 1122: "OP_glLightx", + 1123: "OP_glLightxv", + 1124: "OP_glLineWidthx", + 1125: "OP_glLoadIdentity", + 1126: "OP_glLoadMatrixx", + 1127: "OP_glLogicOp", + 1128: "OP_glMaterialx", + 1129: "OP_glMaterialxv", + 1130: "OP_glMatrixMode", + 1131: "OP_glMultMatrixx", + 1132: "OP_glMultiTexCoord4x", + 1133: "OP_glNormal3x", + 1134: "OP_glNormalPointer", + 1135: "OP_glOrthox", + 1136: "OP_glPixelStorei", + 1137: "OP_glPointParameterx", + 1138: "OP_glPointParameterxv", + 1139: "OP_glPointSizex", + 1140: "OP_glPolygonOffsetx", + 1141: "OP_glPopMatrix", + 1142: "OP_glPushMatrix", + 1143: "OP_glReadPixels", + 1144: "OP_glRotatex", + 1145: "OP_glSampleCoverage", + 1146: "OP_glSampleCoveragex", + 1147: "OP_glScalex", + 1148: "OP_glScissor", + 1149: "OP_glShadeModel", + 1150: "OP_glStencilFunc", + 1151: "OP_glStencilMask", + 1152: "OP_glStencilOp", + 1153: "OP_glTexCoordPointer", + 1154: "OP_glTexEnvi", + 1155: "OP_glTexEnvx", + 1156: "OP_glTexEnviv", + 1157: "OP_glTexEnvxv", + 1158: "OP_glTexImage2D", + 1159: "OP_glTexParameteri", + 1160: "OP_glTexParameterx", + 1161: "OP_glTexParameteriv", + 1162: "OP_glTexParameterxv", + 1163: "OP_glTexSubImage2D", + 1164: "OP_glTranslatex", + 1165: "OP_glVertexPointer", + 1166: "OP_glViewport", + 1167: "OP_glPointSizePointerOES", + 1168: "OP_glVertexPointerOffset", + 1169: "OP_glColorPointerOffset", + 1170: "OP_glNormalPointerOffset", + 1171: "OP_glPointSizePointerOffset", + 1172: "OP_glTexCoordPointerOffset", + 1173: "OP_glWeightPointerOffset", + 1174: "OP_glMatrixIndexPointerOffset", + 1175: "OP_glVertexPointerData", + 1176: "OP_glColorPointerData", + 1177: "OP_glNormalPointerData", + 1178: "OP_glTexCoordPointerData", + 1179: "OP_glPointSizePointerData", + 1180: "OP_glWeightPointerData", + 1181: "OP_glMatrixIndexPointerData", + 1182: "OP_glDrawElementsOffset", + 1183: "OP_glDrawElementsData", + 1184: "OP_glGetCompressedTextureFormats", + 1185: "OP_glFinishRoundTrip", + 1186: "OP_glBlendEquationSeparateOES", + 1187: "OP_glBlendFuncSeparateOES", + 1188: "OP_glBlendEquationOES", + 1189: "OP_glDrawTexsOES", + 1190: "OP_glDrawTexiOES", + 1191: "OP_glDrawTexxOES", + 1192: "OP_glDrawTexsvOES", + 1193: "OP_glDrawTexivOES", + 1194: "OP_glDrawTexxvOES", + 1195: "OP_glDrawTexfOES", + 1196: "OP_glDrawTexfvOES", + 1197: "OP_glEGLImageTargetTexture2DOES", + 1198: "OP_glEGLImageTargetRenderbufferStorageOES", + 1199: "OP_glAlphaFuncxOES", + 1200: "OP_glClearColorxOES", + 1201: "OP_glClearDepthxOES", + 1202: "OP_glClipPlanexOES", + 1203: "OP_glClipPlanexIMG", + 1204: "OP_glColor4xOES", + 1205: "OP_glDepthRangexOES", + 1206: "OP_glFogxOES", + 1207: "OP_glFogxvOES", + 1208: "OP_glFrustumxOES", + 1209: "OP_glGetClipPlanexOES", + 1210: "OP_glGetClipPlanex", + 1211: "OP_glGetFixedvOES", + 1212: "OP_glGetLightxvOES", + 1213: "OP_glGetMaterialxvOES", + 1214: "OP_glGetTexEnvxvOES", + 1215: "OP_glGetTexParameterxvOES", + 1216: "OP_glLightModelxOES", + 1217: "OP_glLightModelxvOES", + 1218: "OP_glLightxOES", + 1219: "OP_glLightxvOES", + 1220: "OP_glLineWidthxOES", + 1221: "OP_glLoadMatrixxOES", + 1222: "OP_glMaterialxOES", + 1223: "OP_glMaterialxvOES", + 1224: "OP_glMultMatrixxOES", + 1225: "OP_glMultiTexCoord4xOES", + 1226: "OP_glNormal3xOES", + 1227: "OP_glOrthoxOES", + 1228: "OP_glPointParameterxOES", + 1229: "OP_glPointParameterxvOES", + 1230: "OP_glPointSizexOES", + 1231: "OP_glPolygonOffsetxOES", + 1232: "OP_glRotatexOES", + 1233: "OP_glSampleCoveragexOES", + 1234: "OP_glScalexOES", + 1235: "OP_glTexEnvxOES", + 1236: "OP_glTexEnvxvOES", + 1237: "OP_glTexParameterxOES", + 1238: "OP_glTexParameterxvOES", + 1239: "OP_glTranslatexOES", + 1240: "OP_glIsRenderbufferOES", + 1241: "OP_glBindRenderbufferOES", + 1242: "OP_glDeleteRenderbuffersOES", + 1243: "OP_glGenRenderbuffersOES", + 1244: "OP_glRenderbufferStorageOES", + 1245: "OP_glGetRenderbufferParameterivOES", + 1246: "OP_glIsFramebufferOES", + 1247: "OP_glBindFramebufferOES", + 1248: "OP_glDeleteFramebuffersOES", + 1249: "OP_glGenFramebuffersOES", + 1250: "OP_glCheckFramebufferStatusOES", + 1251: "OP_glFramebufferRenderbufferOES", + 1252: "OP_glFramebufferTexture2DOES", + 1253: "OP_glGetFramebufferAttachmentParameterivOES", + 1254: "OP_glGenerateMipmapOES", + 1255: "OP_glMapBufferOES", + 1256: "OP_glUnmapBufferOES", + 1257: "OP_glGetBufferPointervOES", + 1258: "OP_glCurrentPaletteMatrixOES", + 1259: "OP_glLoadPaletteFromModelViewMatrixOES", + 1260: "OP_glMatrixIndexPointerOES", + 1261: "OP_glWeightPointerOES", + 1262: "OP_glQueryMatrixxOES", + 1263: "OP_glDepthRangefOES", + 1264: "OP_glFrustumfOES", + 1265: "OP_glOrthofOES", + 1266: "OP_glClipPlanefOES", + 1267: "OP_glClipPlanefIMG", + 1268: "OP_glGetClipPlanefOES", + 1269: "OP_glClearDepthfOES", + 1270: "OP_glTexGenfOES", + 1271: "OP_glTexGenfvOES", + 1272: "OP_glTexGeniOES", + 1273: "OP_glTexGenivOES", + 1274: "OP_glTexGenxOES", + 1275: "OP_glTexGenxvOES", + 1276: "OP_glGetTexGenfvOES", + 1277: "OP_glGetTexGenivOES", + 1278: "OP_glGetTexGenxvOES", + 1279: "OP_glBindVertexArrayOES", + 1280: "OP_glDeleteVertexArraysOES", + 1281: "OP_glGenVertexArraysOES", + 1282: "OP_glIsVertexArrayOES", + 1283: "OP_glDiscardFramebufferEXT", + 1284: "OP_glMultiDrawArraysEXT", + 1285: "OP_glMultiDrawElementsEXT", + 1286: "OP_glMultiDrawArraysSUN", + 1287: "OP_glMultiDrawElementsSUN", + 1288: "OP_glRenderbufferStorageMultisampleIMG", + 1289: "OP_glFramebufferTexture2DMultisampleIMG", + 1290: "OP_glDeleteFencesNV", + 1291: "OP_glGenFencesNV", + 1292: "OP_glIsFenceNV", + 1293: "OP_glTestFenceNV", + 1294: "OP_glGetFenceivNV", + 1295: "OP_glFinishFenceNV", + 1296: "OP_glSetFenceNV", + 1297: "OP_glGetDriverControlsQCOM", + 1298: "OP_glGetDriverControlStringQCOM", + 1299: "OP_glEnableDriverControlQCOM", + 1300: "OP_glDisableDriverControlQCOM", + 1301: "OP_glExtGetTexturesQCOM", + 1302: "OP_glExtGetBuffersQCOM", + 1303: "OP_glExtGetRenderbuffersQCOM", + 1304: "OP_glExtGetFramebuffersQCOM", + 1305: "OP_glExtGetTexLevelParameterivQCOM", + 1306: "OP_glExtTexObjectStateOverrideiQCOM", + 1307: "OP_glExtGetTexSubImageQCOM", + 1308: "OP_glExtGetBufferPointervQCOM", + 1309: "OP_glExtGetShadersQCOM", + 1310: "OP_glExtGetProgramsQCOM", + 1311: "OP_glExtIsProgramBinaryQCOM", + 1312: "OP_glExtGetProgramBinarySourceQCOM", + 1313: "OP_glStartTilingQCOM", + 1314: "OP_glEndTilingQCOM", + 1315: "OP_glGetGraphicsResetStatusEXT", + 1316: "OP_glReadnPixelsEXT", + + # From https://source.corp.google.com/android/device/generic/vulkan-cereal/stream-servers/gles2_dec/gles2_opcodes.h + 2048: "OP_glActiveTexture", + 2049: "OP_glAttachShader", + 2050: "OP_glBindAttribLocation", + 2051: "OP_glBindBuffer", + 2052: "OP_glBindFramebuffer", + 2053: "OP_glBindRenderbuffer", + 2054: "OP_glBindTexture", + 2055: "OP_glBlendColor", + 2056: "OP_glBlendEquation", + 2057: "OP_glBlendEquationSeparate", + 2058: "OP_glBlendFunc", + 2059: "OP_glBlendFuncSeparate", + 2060: "OP_glBufferData", + 2061: "OP_glBufferSubData", + 2062: "OP_glCheckFramebufferStatus", + 2063: "OP_glClear", + 2064: "OP_glClearColor", + 2065: "OP_glClearDepthf", + 2066: "OP_glClearStencil", + 2067: "OP_glColorMask", + 2068: "OP_glCompileShader", + 2069: "OP_glCompressedTexImage2D", + 2070: "OP_glCompressedTexSubImage2D", + 2071: "OP_glCopyTexImage2D", + 2072: "OP_glCopyTexSubImage2D", + 2073: "OP_glCreateProgram", + 2074: "OP_glCreateShader", + 2075: "OP_glCullFace", + 2076: "OP_glDeleteBuffers", + 2077: "OP_glDeleteFramebuffers", + 2078: "OP_glDeleteProgram", + 2079: "OP_glDeleteRenderbuffers", + 2080: "OP_glDeleteShader", + 2081: "OP_glDeleteTextures", + 2082: "OP_glDepthFunc", + 2083: "OP_glDepthMask", + 2084: "OP_glDepthRangef", + 2085: "OP_glDetachShader", + 2086: "OP_glDisable", + 2087: "OP_glDisableVertexAttribArray", + 2088: "OP_glDrawArrays", + 2089: "OP_glDrawElements", + 2090: "OP_glEnable", + 2091: "OP_glEnableVertexAttribArray", + 2092: "OP_glFinish", + 2093: "OP_glFlush", + 2094: "OP_glFramebufferRenderbuffer", + 2095: "OP_glFramebufferTexture2D", + 2096: "OP_glFrontFace", + 2097: "OP_glGenBuffers", + 2098: "OP_glGenerateMipmap", + 2099: "OP_glGenFramebuffers", + 2100: "OP_glGenRenderbuffers", + 2101: "OP_glGenTextures", + 2102: "OP_glGetActiveAttrib", + 2103: "OP_glGetActiveUniform", + 2104: "OP_glGetAttachedShaders", + 2105: "OP_glGetAttribLocation", + 2106: "OP_glGetBooleanv", + 2107: "OP_glGetBufferParameteriv", + 2108: "OP_glGetError", + 2109: "OP_glGetFloatv", + 2110: "OP_glGetFramebufferAttachmentParameteriv", + 2111: "OP_glGetIntegerv", + 2112: "OP_glGetProgramiv", + 2113: "OP_glGetProgramInfoLog", + 2114: "OP_glGetRenderbufferParameteriv", + 2115: "OP_glGetShaderiv", + 2116: "OP_glGetShaderInfoLog", + 2117: "OP_glGetShaderPrecisionFormat", + 2118: "OP_glGetShaderSource", + 2119: "OP_glGetString", + 2120: "OP_glGetTexParameterfv", + 2121: "OP_glGetTexParameteriv", + 2122: "OP_glGetUniformfv", + 2123: "OP_glGetUniformiv", + 2124: "OP_glGetUniformLocation", + 2125: "OP_glGetVertexAttribfv", + 2126: "OP_glGetVertexAttribiv", + 2127: "OP_glGetVertexAttribPointerv", + 2128: "OP_glHint", + 2129: "OP_glIsBuffer", + 2130: "OP_glIsEnabled", + 2131: "OP_glIsFramebuffer", + 2132: "OP_glIsProgram", + 2133: "OP_glIsRenderbuffer", + 2134: "OP_glIsShader", + 2135: "OP_glIsTexture", + 2136: "OP_glLineWidth", + 2137: "OP_glLinkProgram", + 2138: "OP_glPixelStorei", + 2139: "OP_glPolygonOffset", + 2140: "OP_glReadPixels", + 2141: "OP_glReleaseShaderCompiler", + 2142: "OP_glRenderbufferStorage", + 2143: "OP_glSampleCoverage", + 2144: "OP_glScissor", + 2145: "OP_glShaderBinary", + 2146: "OP_glShaderSource", + 2147: "OP_glStencilFunc", + 2148: "OP_glStencilFuncSeparate", + 2149: "OP_glStencilMask", + 2150: "OP_glStencilMaskSeparate", + 2151: "OP_glStencilOp", + 2152: "OP_glStencilOpSeparate", + 2153: "OP_glTexImage2D", + 2154: "OP_glTexParameterf", + 2155: "OP_glTexParameterfv", + 2156: "OP_glTexParameteri", + 2157: "OP_glTexParameteriv", + 2158: "OP_glTexSubImage2D", + 2159: "OP_glUniform1f", + 2160: "OP_glUniform1fv", + 2161: "OP_glUniform1i", + 2162: "OP_glUniform1iv", + 2163: "OP_glUniform2f", + 2164: "OP_glUniform2fv", + 2165: "OP_glUniform2i", + 2166: "OP_glUniform2iv", + 2167: "OP_glUniform3f", + 2168: "OP_glUniform3fv", + 2169: "OP_glUniform3i", + 2170: "OP_glUniform3iv", + 2171: "OP_glUniform4f", + 2172: "OP_glUniform4fv", + 2173: "OP_glUniform4i", + 2174: "OP_glUniform4iv", + 2175: "OP_glUniformMatrix2fv", + 2176: "OP_glUniformMatrix3fv", + 2177: "OP_glUniformMatrix4fv", + 2178: "OP_glUseProgram", + 2179: "OP_glValidateProgram", + 2180: "OP_glVertexAttrib1f", + 2181: "OP_glVertexAttrib1fv", + 2182: "OP_glVertexAttrib2f", + 2183: "OP_glVertexAttrib2fv", + 2184: "OP_glVertexAttrib3f", + 2185: "OP_glVertexAttrib3fv", + 2186: "OP_glVertexAttrib4f", + 2187: "OP_glVertexAttrib4fv", + 2188: "OP_glVertexAttribPointer", + 2189: "OP_glViewport", + 2190: "OP_glEGLImageTargetTexture2DOES", + 2191: "OP_glEGLImageTargetRenderbufferStorageOES", + 2192: "OP_glGetProgramBinaryOES", + 2193: "OP_glProgramBinaryOES", + 2194: "OP_glMapBufferOES", + 2195: "OP_glUnmapBufferOES", + 2196: "OP_glTexImage3DOES", + 2197: "OP_glTexSubImage3DOES", + 2198: "OP_glCopyTexSubImage3DOES", + 2199: "OP_glCompressedTexImage3DOES", + 2200: "OP_glCompressedTexSubImage3DOES", + 2201: "OP_glFramebufferTexture3DOES", + 2202: "OP_glBindVertexArrayOES", + 2203: "OP_glDeleteVertexArraysOES", + 2204: "OP_glGenVertexArraysOES", + 2205: "OP_glIsVertexArrayOES", + 2206: "OP_glDiscardFramebufferEXT", + 2207: "OP_glMultiDrawArraysEXT", + 2208: "OP_glMultiDrawElementsEXT", + 2209: "OP_glGetPerfMonitorGroupsAMD", + 2210: "OP_glGetPerfMonitorCountersAMD", + 2211: "OP_glGetPerfMonitorGroupStringAMD", + 2212: "OP_glGetPerfMonitorCounterStringAMD", + 2213: "OP_glGetPerfMonitorCounterInfoAMD", + 2214: "OP_glGenPerfMonitorsAMD", + 2215: "OP_glDeletePerfMonitorsAMD", + 2216: "OP_glSelectPerfMonitorCountersAMD", + 2217: "OP_glBeginPerfMonitorAMD", + 2218: "OP_glEndPerfMonitorAMD", + 2219: "OP_glGetPerfMonitorCounterDataAMD", + 2220: "OP_glRenderbufferStorageMultisampleIMG", + 2221: "OP_glFramebufferTexture2DMultisampleIMG", + 2222: "OP_glDeleteFencesNV", + 2223: "OP_glGenFencesNV", + 2224: "OP_glIsFenceNV", + 2225: "OP_glTestFenceNV", + 2226: "OP_glGetFenceivNV", + 2227: "OP_glFinishFenceNV", + 2228: "OP_glSetFenceNV", + 2229: "OP_glCoverageMaskNV", + 2230: "OP_glCoverageOperationNV", + 2231: "OP_glGetDriverControlsQCOM", + 2232: "OP_glGetDriverControlStringQCOM", + 2233: "OP_glEnableDriverControlQCOM", + 2234: "OP_glDisableDriverControlQCOM", + 2235: "OP_glExtGetTexturesQCOM", + 2236: "OP_glExtGetBuffersQCOM", + 2237: "OP_glExtGetRenderbuffersQCOM", + 2238: "OP_glExtGetFramebuffersQCOM", + 2239: "OP_glExtGetTexLevelParameterivQCOM", + 2240: "OP_glExtTexObjectStateOverrideiQCOM", + 2241: "OP_glExtGetTexSubImageQCOM", + 2242: "OP_glExtGetBufferPointervQCOM", + 2243: "OP_glExtGetShadersQCOM", + 2244: "OP_glExtGetProgramsQCOM", + 2245: "OP_glExtIsProgramBinaryQCOM", + 2246: "OP_glExtGetProgramBinarySourceQCOM", + 2247: "OP_glStartTilingQCOM", + 2248: "OP_glEndTilingQCOM", + 2249: "OP_glVertexAttribPointerData", + 2250: "OP_glVertexAttribPointerOffset", + 2251: "OP_glDrawElementsOffset", + 2252: "OP_glDrawElementsData", + 2253: "OP_glGetCompressedTextureFormats", + 2254: "OP_glShaderString", + 2255: "OP_glFinishRoundTrip", + 2256: "OP_glGenVertexArrays", + 2257: "OP_glBindVertexArray", + 2258: "OP_glDeleteVertexArrays", + 2259: "OP_glIsVertexArray", + 2260: "OP_glMapBufferRange", + 2261: "OP_glUnmapBuffer", + 2262: "OP_glFlushMappedBufferRange", + 2263: "OP_glMapBufferRangeAEMU", + 2264: "OP_glUnmapBufferAEMU", + 2265: "OP_glFlushMappedBufferRangeAEMU", + 2266: "OP_glReadPixelsOffsetAEMU", + 2267: "OP_glCompressedTexImage2DOffsetAEMU", + 2268: "OP_glCompressedTexSubImage2DOffsetAEMU", + 2269: "OP_glTexImage2DOffsetAEMU", + 2270: "OP_glTexSubImage2DOffsetAEMU", + 2271: "OP_glBindBufferRange", + 2272: "OP_glBindBufferBase", + 2273: "OP_glCopyBufferSubData", + 2274: "OP_glClearBufferiv", + 2275: "OP_glClearBufferuiv", + 2276: "OP_glClearBufferfv", + 2277: "OP_glClearBufferfi", + 2278: "OP_glGetBufferParameteri64v", + 2279: "OP_glGetBufferPointerv", + 2280: "OP_glUniformBlockBinding", + 2281: "OP_glGetUniformBlockIndex", + 2282: "OP_glGetUniformIndices", + 2283: "OP_glGetUniformIndicesAEMU", + 2284: "OP_glGetActiveUniformBlockiv", + 2285: "OP_glGetActiveUniformBlockName", + 2286: "OP_glUniform1ui", + 2287: "OP_glUniform2ui", + 2288: "OP_glUniform3ui", + 2289: "OP_glUniform4ui", + 2290: "OP_glUniform1uiv", + 2291: "OP_glUniform2uiv", + 2292: "OP_glUniform3uiv", + 2293: "OP_glUniform4uiv", + 2294: "OP_glUniformMatrix2x3fv", + 2295: "OP_glUniformMatrix3x2fv", + 2296: "OP_glUniformMatrix2x4fv", + 2297: "OP_glUniformMatrix4x2fv", + 2298: "OP_glUniformMatrix3x4fv", + 2299: "OP_glUniformMatrix4x3fv", + 2300: "OP_glGetUniformuiv", + 2301: "OP_glGetActiveUniformsiv", + 2302: "OP_glVertexAttribI4i", + 2303: "OP_glVertexAttribI4ui", + 2304: "OP_glVertexAttribI4iv", + 2305: "OP_glVertexAttribI4uiv", + 2306: "OP_glVertexAttribIPointer", + 2307: "OP_glVertexAttribIPointerOffsetAEMU", + 2308: "OP_glVertexAttribIPointerDataAEMU", + 2309: "OP_glGetVertexAttribIiv", + 2310: "OP_glGetVertexAttribIuiv", + 2311: "OP_glVertexAttribDivisor", + 2312: "OP_glDrawArraysInstanced", + 2313: "OP_glDrawElementsInstanced", + 2314: "OP_glDrawElementsInstancedDataAEMU", + 2315: "OP_glDrawElementsInstancedOffsetAEMU", + 2316: "OP_glDrawRangeElements", + 2317: "OP_glDrawRangeElementsDataAEMU", + 2318: "OP_glDrawRangeElementsOffsetAEMU", + 2319: "OP_glFenceSync", + 2320: "OP_glClientWaitSync", + 2321: "OP_glWaitSync", + 2322: "OP_glDeleteSync", + 2323: "OP_glIsSync", + 2324: "OP_glGetSynciv", + 2325: "OP_glFenceSyncAEMU", + 2326: "OP_glClientWaitSyncAEMU", + 2327: "OP_glWaitSyncAEMU", + 2328: "OP_glDeleteSyncAEMU", + 2329: "OP_glIsSyncAEMU", + 2330: "OP_glGetSyncivAEMU", + 2331: "OP_glDrawBuffers", + 2332: "OP_glReadBuffer", + 2333: "OP_glBlitFramebuffer", + 2334: "OP_glInvalidateFramebuffer", + 2335: "OP_glInvalidateSubFramebuffer", + 2336: "OP_glFramebufferTextureLayer", + 2337: "OP_glRenderbufferStorageMultisample", + 2338: "OP_glTexStorage2D", + 2339: "OP_glGetInternalformativ", + 2340: "OP_glBeginTransformFeedback", + 2341: "OP_glEndTransformFeedback", + 2342: "OP_glGenTransformFeedbacks", + 2343: "OP_glDeleteTransformFeedbacks", + 2344: "OP_glBindTransformFeedback", + 2345: "OP_glPauseTransformFeedback", + 2346: "OP_glResumeTransformFeedback", + 2347: "OP_glIsTransformFeedback", + 2348: "OP_glTransformFeedbackVaryings", + 2349: "OP_glTransformFeedbackVaryingsAEMU", + 2350: "OP_glGetTransformFeedbackVarying", + 2351: "OP_glGenSamplers", + 2352: "OP_glDeleteSamplers", + 2353: "OP_glBindSampler", + 2354: "OP_glSamplerParameterf", + 2355: "OP_glSamplerParameteri", + 2356: "OP_glSamplerParameterfv", + 2357: "OP_glSamplerParameteriv", + 2358: "OP_glGetSamplerParameterfv", + 2359: "OP_glGetSamplerParameteriv", + 2360: "OP_glIsSampler", + 2361: "OP_glGenQueries", + 2362: "OP_glDeleteQueries", + 2363: "OP_glBeginQuery", + 2364: "OP_glEndQuery", + 2365: "OP_glGetQueryiv", + 2366: "OP_glGetQueryObjectuiv", + 2367: "OP_glIsQuery", + 2368: "OP_glProgramParameteri", + 2369: "OP_glProgramBinary", + 2370: "OP_glGetProgramBinary", + 2371: "OP_glGetFragDataLocation", + 2372: "OP_glGetInteger64v", + 2373: "OP_glGetIntegeri_v", + 2374: "OP_glGetInteger64i_v", + 2375: "OP_glTexImage3D", + 2376: "OP_glTexImage3DOffsetAEMU", + 2377: "OP_glTexStorage3D", + 2378: "OP_glTexSubImage3D", + 2379: "OP_glTexSubImage3DOffsetAEMU", + 2380: "OP_glCompressedTexImage3D", + 2381: "OP_glCompressedTexImage3DOffsetAEMU", + 2382: "OP_glCompressedTexSubImage3D", + 2383: "OP_glCompressedTexSubImage3DOffsetAEMU", + 2384: "OP_glCopyTexSubImage3D", + 2385: "OP_glGetStringi", + 2386: "OP_glGetBooleani_v", + 2387: "OP_glMemoryBarrier", + 2388: "OP_glMemoryBarrierByRegion", + 2389: "OP_glGenProgramPipelines", + 2390: "OP_glDeleteProgramPipelines", + 2391: "OP_glBindProgramPipeline", + 2392: "OP_glGetProgramPipelineiv", + 2393: "OP_glGetProgramPipelineInfoLog", + 2394: "OP_glValidateProgramPipeline", + 2395: "OP_glIsProgramPipeline", + 2396: "OP_glUseProgramStages", + 2397: "OP_glActiveShaderProgram", + 2398: "OP_glCreateShaderProgramv", + 2399: "OP_glCreateShaderProgramvAEMU", + 2400: "OP_glProgramUniform1f", + 2401: "OP_glProgramUniform2f", + 2402: "OP_glProgramUniform3f", + 2403: "OP_glProgramUniform4f", + 2404: "OP_glProgramUniform1i", + 2405: "OP_glProgramUniform2i", + 2406: "OP_glProgramUniform3i", + 2407: "OP_glProgramUniform4i", + 2408: "OP_glProgramUniform1ui", + 2409: "OP_glProgramUniform2ui", + 2410: "OP_glProgramUniform3ui", + 2411: "OP_glProgramUniform4ui", + 2412: "OP_glProgramUniform1fv", + 2413: "OP_glProgramUniform2fv", + 2414: "OP_glProgramUniform3fv", + 2415: "OP_glProgramUniform4fv", + 2416: "OP_glProgramUniform1iv", + 2417: "OP_glProgramUniform2iv", + 2418: "OP_glProgramUniform3iv", + 2419: "OP_glProgramUniform4iv", + 2420: "OP_glProgramUniform1uiv", + 2421: "OP_glProgramUniform2uiv", + 2422: "OP_glProgramUniform3uiv", + 2423: "OP_glProgramUniform4uiv", + 2424: "OP_glProgramUniformMatrix2fv", + 2425: "OP_glProgramUniformMatrix3fv", + 2426: "OP_glProgramUniformMatrix4fv", + 2427: "OP_glProgramUniformMatrix2x3fv", + 2428: "OP_glProgramUniformMatrix3x2fv", + 2429: "OP_glProgramUniformMatrix2x4fv", + 2430: "OP_glProgramUniformMatrix4x2fv", + 2431: "OP_glProgramUniformMatrix3x4fv", + 2432: "OP_glProgramUniformMatrix4x3fv", + 2433: "OP_glGetProgramInterfaceiv", + 2434: "OP_glGetProgramResourceiv", + 2435: "OP_glGetProgramResourceIndex", + 2436: "OP_glGetProgramResourceLocation", + 2437: "OP_glGetProgramResourceName", + 2438: "OP_glBindImageTexture", + 2439: "OP_glDispatchCompute", + 2440: "OP_glDispatchComputeIndirect", + 2441: "OP_glBindVertexBuffer", + 2442: "OP_glVertexAttribBinding", + 2443: "OP_glVertexAttribFormat", + 2444: "OP_glVertexAttribIFormat", + 2445: "OP_glVertexBindingDivisor", + 2446: "OP_glDrawArraysIndirect", + 2447: "OP_glDrawArraysIndirectDataAEMU", + 2448: "OP_glDrawArraysIndirectOffsetAEMU", + 2449: "OP_glDrawElementsIndirect", + 2450: "OP_glDrawElementsIndirectDataAEMU", + 2451: "OP_glDrawElementsIndirectOffsetAEMU", + 2452: "OP_glTexStorage2DMultisample", + 2453: "OP_glSampleMaski", + 2454: "OP_glGetMultisamplefv", + 2455: "OP_glFramebufferParameteri", + 2456: "OP_glGetFramebufferParameteriv", + 2457: "OP_glGetTexLevelParameterfv", + 2458: "OP_glGetTexLevelParameteriv", + 2459: "OP_glMapBufferRangeDMA", + 2460: "OP_glUnmapBufferDMA", + 2461: "OP_glMapBufferRangeDirect", + 2462: "OP_glUnmapBufferDirect", + 2463: "OP_glFlushMappedBufferRangeDirect", + 2464: "OP_glGetGraphicsResetStatusEXT", + 2465: "OP_glReadnPixelsEXT", + 2466: "OP_glGetnUniformfvEXT", + 2467: "OP_glGetnUniformivEXT", + 2468: "OP_glDrawArraysNullAEMU", + 2469: "OP_glDrawElementsNullAEMU", + 2470: "OP_glDrawElementsOffsetNullAEMU", + 2471: "OP_glDrawElementsDataNullAEMU", + 2472: "OP_glUnmapBufferAsyncAEMU", + 2473: "OP_glFlushMappedBufferRangeAEMU2", + 2474: "OP_glBufferDataSyncAEMU", +} diff --git a/stream-servers/CMakeLists.txt b/stream-servers/CMakeLists.txt index b5fc30b4..42c12908 100644 --- a/stream-servers/CMakeLists.txt +++ b/stream-servers/CMakeLists.txt @@ -236,4 +236,6 @@ target_link_libraries( gfxstream-host-common-testing-support gtest gmock) -gtest_discover_tests(Vulkan_unittests)
\ No newline at end of file +gtest_discover_tests(Vulkan_unittests) + +set_test_include_files() diff --git a/stream-servers/DisplayVk.cpp b/stream-servers/DisplayVk.cpp index d353b7fc..fb6cea17 100644 --- a/stream-servers/DisplayVk.cpp +++ b/stream-servers/DisplayVk.cpp @@ -4,6 +4,7 @@ #include <chrono> #include <glm/glm.hpp> #include <glm/gtx/matrix_transform_2d.hpp> +#include <thread> #include "host-common/GfxstreamFatalError.h" #include "host-common/logging.h" @@ -45,9 +46,26 @@ bool shouldRecreateSwapchain(VkResult result) { } } +VkResult waitForVkQueueIdleWithRetry(const goldfish_vk::VulkanDispatch& vk, VkQueue queue) { + using namespace std::chrono_literals; + constexpr uint32_t retryLimit = 5; + constexpr std::chrono::duration waitInterval = 4ms; + VkResult res = vk.vkQueueWaitIdle(queue); + for (uint32_t retryTimes = 1; retryTimes < retryLimit && res == VK_TIMEOUT; retryTimes++) { + INFO("VK_TIMEOUT returned from vkQueueWaitIdle with %" PRIu32 " attempt. Wait for %" PRIu32 + "ms before another attempt.", + retryTimes, + static_cast<uint32_t>( + std::chrono::duration_cast<std::chrono::milliseconds>(waitInterval).count())); + std::this_thread::sleep_for(waitInterval); + res = vk.vkQueueWaitIdle(queue); + } + return res; +} + } // namespace -DisplayVk::DisplayVk(const goldfish_vk::VulkanDispatch &vk, VkPhysicalDevice vkPhysicalDevice, +DisplayVk::DisplayVk(const goldfish_vk::VulkanDispatch& vk, VkPhysicalDevice vkPhysicalDevice, uint32_t swapChainQueueFamilyIndex, uint32_t compositorQueueFamilyIndex, VkDevice vkDevice, VkQueue compositorVkQueue, std::shared_ptr<android::base::Lock> compositorVkQueueLock, @@ -97,11 +115,11 @@ DisplayVk::DisplayVk(const goldfish_vk::VulkanDispatch &vk, VkPhysicalDevice vkP DisplayVk::~DisplayVk() { { android::base::AutoLock lock(*m_swapChainVkQueueLock); - VK_CHECK(m_vk.vkQueueWaitIdle(m_swapChainVkQueue)); + VK_CHECK(waitForVkQueueIdleWithRetry(m_vk, m_swapChainVkQueue)); } { android::base::AutoLock lock(*m_compositorVkQueueLock); - VK_CHECK(m_vk.vkQueueWaitIdle(m_compositorVkQueue)); + VK_CHECK(waitForVkQueueIdleWithRetry(m_vk, m_compositorVkQueue)); } m_postResourceFuture = std::nullopt; m_composeResourceFuture = std::nullopt; @@ -116,11 +134,11 @@ DisplayVk::~DisplayVk() { void DisplayVk::bindToSurface(VkSurfaceKHR surface, uint32_t width, uint32_t height) { { android::base::AutoLock lock(*m_compositorVkQueueLock); - VK_CHECK(m_vk.vkQueueWaitIdle(m_compositorVkQueue)); + VK_CHECK(waitForVkQueueIdleWithRetry(m_vk, m_compositorVkQueue)); } { android::base::AutoLock lock(*m_swapChainVkQueueLock); - VK_CHECK(m_vk.vkQueueWaitIdle(m_swapChainVkQueue)); + VK_CHECK(waitForVkQueueIdleWithRetry(m_vk, m_swapChainVkQueue)); } m_postResourceFuture = std::nullopt; m_composeResourceFuture = std::nullopt; @@ -137,15 +155,20 @@ void DisplayVk::bindToSurface(VkSurfaceKHR surface, uint32_t width, uint32_t hei auto swapChainCi = SwapChainStateVk::createSwapChainCi( m_vk, surface, m_vkPhysicalDevice, width, height, {m_swapChainQueueFamilyIndex, m_compositorQueueFamilyIndex}); + if (!swapChainCi) { + GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) + << "Failed to create VkSwapchainCreateInfoKHR."; + } VkFormatProperties formatProps; - m_vk.vkGetPhysicalDeviceFormatProperties(m_vkPhysicalDevice, swapChainCi->imageFormat, - &formatProps); + m_vk.vkGetPhysicalDeviceFormatProperties(m_vkPhysicalDevice, + swapChainCi->mCreateInfo.imageFormat, &formatProps); if (!(formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "DisplayVk: The image format chosen for present VkImage can't be used as the color " "attachment, and therefore can't be used as the render target of CompositorVk."; } - m_swapChainStateVk = std::make_unique<SwapChainStateVk>(m_vk, m_vkDevice, *swapChainCi); + m_swapChainStateVk = + std::make_unique<SwapChainStateVk>(m_vk, m_vkDevice, swapChainCi->mCreateInfo); m_compositorVk = CompositorVk::create( m_vk, m_vkDevice, m_vkPhysicalDevice, m_compositorVkQueue, m_compositorVkQueueLock, k_compositorVkRenderTargetFormat, VK_IMAGE_LAYOUT_UNDEFINED, @@ -172,7 +195,7 @@ void DisplayVk::bindToSurface(VkSurfaceKHR surface, uint32_t width, uint32_t hei } std::shared_ptr<DisplayVk::DisplayBufferInfo> DisplayVk::createDisplayBuffer( - VkImage image, const VkImageCreateInfo &vkImageCreateInfo) { + VkImage image, const VkImageCreateInfo& vkImageCreateInfo) { return std::shared_ptr<DisplayBufferInfo>( new DisplayBufferInfo(m_vk, m_vkDevice, vkImageCreateInfo, image)); } @@ -372,7 +395,7 @@ std::tuple<bool, std::shared_future<void>> DisplayVk::compose( DISPLAY_VK_ERROR("warning: null ptr passed to compose buffer for layer %d.", i); continue; } - const auto &db = *composeBuffers[i]; + const auto& db = *composeBuffers[i]; if (!canCompositeFrom(db.m_vkImageCreateInfo)) { DISPLAY_VK_ERROR("Can't composite from a display buffer. Skip the layer."); continue; @@ -500,7 +523,7 @@ VkFormatFeatureFlags DisplayVk::getFormatFeatures(VkFormat format, VkImageTiling m_vk.vkGetPhysicalDeviceFormatProperties(m_vkPhysicalDevice, format, &formatProperties); i = m_vkFormatProperties.emplace(format, formatProperties).first; } - const VkFormatProperties &formatProperties = i->second; + const VkFormatProperties& formatProperties = i->second; VkFormatFeatureFlags formatFeatures = 0; if (tiling == VK_IMAGE_TILING_LINEAR) { formatFeatures = formatProperties.linearTilingFeatures; @@ -512,7 +535,7 @@ VkFormatFeatureFlags DisplayVk::getFormatFeatures(VkFormat format, VkImageTiling return formatFeatures; } -bool DisplayVk::canPost(const VkImageCreateInfo &postImageCi) { +bool DisplayVk::canPost(const VkImageCreateInfo& postImageCi) { // According to VUID-vkCmdBlitImage-srcImage-01999, the format features of srcImage must contain // VK_FORMAT_FEATURE_BLIT_SRC_BIT. VkFormatFeatureFlags formatFeatures = getFormatFeatures(postImageCi.format, postImageCi.tiling); @@ -603,7 +626,7 @@ bool DisplayVk::canPost(const VkImageCreateInfo &postImageCi) { return true; } -bool DisplayVk::canCompositeFrom(const VkImageCreateInfo &imageCi) { +bool DisplayVk::canCompositeFrom(const VkImageCreateInfo& imageCi) { VkFormatFeatureFlags formatFeatures = getFormatFeatures(imageCi.format, imageCi.tiling); if (!(formatFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { DISPLAY_VK_ERROR( @@ -616,7 +639,7 @@ bool DisplayVk::canCompositeFrom(const VkImageCreateInfo &imageCi) { return true; } -bool DisplayVk::canCompositeTo(const VkImageCreateInfo &imageCi) { +bool DisplayVk::canCompositeTo(const VkImageCreateInfo& imageCi) { VkFormatFeatureFlags formatFeatures = getFormatFeatures(imageCi.format, imageCi.tiling); if (!(formatFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { DISPLAY_VK_ERROR( @@ -645,14 +668,14 @@ bool DisplayVk::canCompositeTo(const VkImageCreateInfo &imageCi) { bool DisplayVk::compareAndSaveComposition( uint32_t renderTargetIndex, uint32_t numLayers, const ComposeLayer layers[], - const std::vector<std::shared_ptr<DisplayBufferInfo>> &composeBuffers) { + const std::vector<std::shared_ptr<DisplayBufferInfo>>& composeBuffers) { if (!m_surfaceState) { GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Haven't bound to a surface, can't compare and save composition."; } auto [iPrevComposition, compositionNotFound] = m_surfaceState->m_prevCompositions.emplace(renderTargetIndex, 0); - auto &prevComposition = iPrevComposition->second; + auto& prevComposition = iPrevComposition->second; bool compositionChanged = false; if (numLayers == prevComposition.size()) { for (int i = 0; i < numLayers; i++) { @@ -674,7 +697,7 @@ bool DisplayVk::compareAndSaveComposition( compositionChanged = true; break; } - const auto &prevLayer = *prevComposition[i]; + const auto& prevLayer = *prevComposition[i]; const auto prevDisplayBufferPtr = prevLayer.m_displayBuffer.lock(); // prevLayer.m_displayBuffer is a weak pointer, so if // prevDisplayBufferPtr is null, the color buffer @@ -687,7 +710,7 @@ bool DisplayVk::compareAndSaveComposition( compositionChanged = true; break; } - const auto &prevHwc2Layer = prevLayer.m_hwc2Layer; + const auto& prevHwc2Layer = prevLayer.m_hwc2Layer; const auto hwc2Layer = layers[i]; compositionChanged = (prevHwc2Layer.cbHandle != hwc2Layer.cbHandle) || @@ -731,9 +754,9 @@ bool DisplayVk::compareAndSaveComposition( return needsSave; } -DisplayVk::DisplayBufferInfo::DisplayBufferInfo(const goldfish_vk::VulkanDispatch &vk, +DisplayVk::DisplayBufferInfo::DisplayBufferInfo(const goldfish_vk::VulkanDispatch& vk, VkDevice vkDevice, - const VkImageCreateInfo &vkImageCreateInfo, + const VkImageCreateInfo& vkImageCreateInfo, VkImage image) : m_vk(vk), m_vkDevice(vkDevice), @@ -795,7 +818,7 @@ DisplayVk::PostResource::~PostResource() { m_vk.vkDestroySemaphore(m_vkDevice, m_swapchainImageReleaseSemaphore, nullptr); } -DisplayVk::PostResource::PostResource(const goldfish_vk::VulkanDispatch &vk, VkDevice vkDevice, +DisplayVk::PostResource::PostResource(const goldfish_vk::VulkanDispatch& vk, VkDevice vkDevice, VkCommandPool vkCommandPool, VkFence swapchainImageReleaseFence, VkSemaphore swapchainImageAcquireSemaphore, @@ -835,7 +858,7 @@ DisplayVk::ComposeResource::~ComposeResource() { m_vk.vkDestroyFence(m_vkDevice, m_composeCompleteFence, nullptr); } -DisplayVk::ComposeResource::ComposeResource(const goldfish_vk::VulkanDispatch &vk, +DisplayVk::ComposeResource::ComposeResource(const goldfish_vk::VulkanDispatch& vk, VkDevice vkDevice, VkCommandPool vkCommandPool, VkFence composeCompleteFence, VkCommandBuffer vkCommandBuffer) diff --git a/stream-servers/FrameBuffer.cpp b/stream-servers/FrameBuffer.cpp index 35645537..71a450f0 100644 --- a/stream-servers/FrameBuffer.cpp +++ b/stream-servers/FrameBuffer.cpp @@ -16,6 +16,7 @@ #include "FrameBuffer.h" +#include <iomanip> #include <stdio.h> #include <string.h> #include <time.h> @@ -402,6 +403,7 @@ bool FrameBuffer::initialize(int width, int height, bool useSubWindow, } } if (vkEmu) { + fb->m_vulkanEnabled = true; if (feature_is_enabled(kFeature_VulkanNativeSwapchain)) { fb->m_vkInstance = vkEmu->instance; } @@ -413,7 +415,6 @@ bool FrameBuffer::initialize(int width, int height, bool useSubWindow, GL_LOG("Doesn't support id properties, no vulkan device UUID"); fprintf(stderr, "%s: Doesn't support id properties, no vulkan device UUID\n", __func__); } - fb->m_glRenderer = std::string(vkEmu->deviceInfo.physdevProps.deviceName); } if (s_egl.eglUseOsEglApi) { @@ -752,10 +753,49 @@ bool FrameBuffer::initialize(int width, int height, bool useSubWindow, // Cache the GL strings so we don't have to think about threading or // current-context when asked for them. // - fb->m_glVendor = std::string((const char*)s_gles2.glGetString(GL_VENDOR)); - fb->m_glRenderer = std::string((const char*)s_gles2.glGetString(GL_RENDERER)); - fb->m_glVersion = std::string((const char*)s_gles2.glGetString(GL_VERSION)); - fb->m_glExtensions = std::string((const char*)s_gles2.glGetString(GL_EXTENSIONS)); + bool useVulkanGraphicsDiagInfo = + vkEmu && feature_is_enabled(kFeature_VulkanNativeSwapchain) && fb->m_guestUsesAngle; + + if (useVulkanGraphicsDiagInfo) { + fb->m_graphicsAdapterVendor = vkEmu->deviceInfo.driverVendor; + fb->m_graphicsAdapterName = vkEmu->deviceInfo.physdevProps.deviceName; + + uint32_t vkVersion = vkEmu->vulkanInstanceVersion; + + std::stringstream versionStringBuilder; + versionStringBuilder << "Vulkan " << VK_API_VERSION_MAJOR(vkVersion) << "." + << VK_API_VERSION_MINOR(vkVersion) << "." + << VK_API_VERSION_PATCH(vkVersion) << " " + << vkEmu->deviceInfo.driverVendor << " " + << vkEmu->deviceInfo.driverVersion; + fb->m_graphicsApiVersion = versionStringBuilder.str(); + + std::stringstream instanceExtensionsStringBuilder; + for (auto& ext : vkEmu->instanceExtensions) { + if (instanceExtensionsStringBuilder.tellp() != 0) { + instanceExtensionsStringBuilder << " "; + } + instanceExtensionsStringBuilder << ext.extensionName; + } + + fb->m_graphicsApiExtensions = instanceExtensionsStringBuilder.str(); + + std::stringstream deviceExtensionsStringBuilder; + for (auto& ext : vkEmu->deviceInfo.extensions) { + if (deviceExtensionsStringBuilder.tellp() != 0) { + deviceExtensionsStringBuilder << " "; + } + deviceExtensionsStringBuilder << ext.extensionName; + } + + fb->m_graphicsDeviceExtensions = deviceExtensionsStringBuilder.str(); + } else { + fb->m_graphicsAdapterVendor = (const char*)s_gles2.glGetString(GL_VENDOR); + fb->m_graphicsAdapterName = (const char*)s_gles2.glGetString(GL_RENDERER); + fb->m_graphicsApiVersion = (const char*)s_gles2.glGetString(GL_VERSION); + fb->m_graphicsApiExtensions = (const char*)s_gles2.glGetString(GL_EXTENSIONS); + fb->m_graphicsDeviceExtensions = "N/A"; + } // Attempt to get the device UUID of the gles and match with Vulkan. If // they match, interop is possible. If they don't, then don't trust the @@ -796,11 +836,6 @@ bool FrameBuffer::initialize(int width, int height, bool useSubWindow, } } - GL_LOG("GL Vendor %s", fb->m_glVendor.c_str()); - GL_LOG("GL Renderer %s", fb->m_glRenderer.c_str()); - GL_LOG("GL Version %s", fb->m_glVersion.c_str()); - GL_LOG("GL Extensions %s", fb->m_glExtensions.c_str()); - fb->m_textureDraw = new TextureDraw(); if (!fb->m_textureDraw) { ERR("Failed: creation of TextureDraw instance"); @@ -831,6 +866,12 @@ bool FrameBuffer::initialize(int width, int height, bool useSubWindow, } } + INFO("Graphics Adapter Vendor %s", fb->m_graphicsAdapterVendor.c_str()); + INFO("Graphics Adapter %s", fb->m_graphicsAdapterName.c_str()); + INFO("Graphics API Version %s", fb->m_graphicsApiVersion.c_str()); + INFO("Graphics API Extensions %s", fb->m_graphicsApiExtensions.c_str()); + INFO("Graphics Device Extensions %s", fb->m_graphicsDeviceExtensions.c_str()); + // Start up the single sync thread. If we are using Vulkan native // swapchain, then don't initialize SyncThread worker threads with EGL // contexts. diff --git a/stream-servers/FrameBuffer.h b/stream-servers/FrameBuffer.h index 79e2e809..138bad0f 100644 --- a/stream-servers/FrameBuffer.h +++ b/stream-servers/FrameBuffer.h @@ -190,9 +190,9 @@ class FrameBuffer { // that are owned by the instance (and must not be freed by the caller). void getGLStrings(const char** vendor, const char** renderer, const char** version) const { - *vendor = m_glVendor.c_str(); - *renderer = m_glRenderer.c_str(); - *version = m_glVersion.c_str(); + *vendor = m_graphicsAdapterVendor.c_str(); + *renderer = m_graphicsAdapterName.c_str(); + *version = m_graphicsApiVersion.c_str(); } // Create a new RenderContext instance for this display instance. @@ -516,6 +516,7 @@ class FrameBuffer { bool isFastBlitSupported() const { return m_fastBlitSupported; } bool isVulkanInteropSupported() const { return m_vulkanInteropSupported; } + bool isVulkanEnabled() const { return m_vulkanEnabled; } bool importMemoryToColorBuffer( #ifdef _WIN32 void* handle, @@ -742,10 +743,11 @@ class FrameBuffer { std::unique_ptr<ReadbackWorker> m_readbackWorker; android::base::WorkerThread<Readback> m_readbackThread; - std::string m_glVendor; - std::string m_glRenderer; - std::string m_glVersion; - std::string m_glExtensions; + std::string m_graphicsAdapterVendor; + std::string m_graphicsAdapterName; + std::string m_graphicsApiVersion; + std::string m_graphicsApiExtensions; + std::string m_graphicsDeviceExtensions; // The host associates color buffers with guest processes for memory // cleanup. Guest processes are identified with a host generated unique ID. @@ -780,6 +782,7 @@ class FrameBuffer { bool m_fastBlitSupported = false; bool m_vulkanInteropSupported = false; + bool m_vulkanEnabled = false; bool m_guestUsesAngle = false; // Whether the guest manages ColorBuffer lifetime // so we don't need refcounting on the host side. diff --git a/stream-servers/PostWorker.cpp b/stream-servers/PostWorker.cpp index d8cb3807..7ec16c84 100644 --- a/stream-servers/PostWorker.cpp +++ b/stream-servers/PostWorker.cpp @@ -17,6 +17,8 @@ #include <string.h> +#include <chrono> + #include "ColorBuffer.h" #include "Debug.h" #include "DispatchTables.h" @@ -26,6 +28,7 @@ #include "RenderThreadInfo.h" #include "base/Tracing.h" #include "host-common/GfxstreamFatalError.h" +#include "host-common/logging.h" #include "host-common/misc.h" #include "vulkan/VkCommonOperations.h" @@ -499,7 +502,11 @@ void PostWorker::compose(ComposeDevice* p, uint32_t bufferSize, auto completedFuture = std::async(std::launch::deferred, [] {}).share(); auto composeDevice = reinterpret_cast<const ComposeDevice*>(buffer.data()); + if (!isComposeTargetReady(composeDevice->targetHandle)) { + ERR("The last composition on the target buffer hasn't completed."); + } composeImpl(composeDevice); + m_composeTargetToComposeFuture.emplace(composeDevice->targetHandle, completedFuture); (*callback)(completedFuture); })); } @@ -512,7 +519,12 @@ void PostWorker::compose(ComposeDevice_v2* p, uint32_t bufferSize, callback = std::move(callback), this] { auto composeDevice = reinterpret_cast<const ComposeDevice_v2*>(buffer.data()); - (*callback)(composev2Impl(composeDevice)); + if (!isComposeTargetReady(composeDevice->targetHandle)) { + ERR("The last composition on the target buffer hasn't completed."); + } + auto completedFuture = composev2Impl(composeDevice); + m_composeTargetToComposeFuture.emplace(composeDevice->targetHandle, completedFuture); + (*callback)(completedFuture); })); } @@ -534,3 +546,21 @@ void PostWorker::runTask(std::packaged_task<void()> task) { (*taskPtr)(); } } + +bool PostWorker::isComposeTargetReady(uint32_t targetHandle) { + // Even if the target ColorBuffer has already been destroyed, the compose future should have + // been waited and set to the ready state. + for (auto i = m_composeTargetToComposeFuture.begin(); + i != m_composeTargetToComposeFuture.end();) { + auto& composeFuture = i->second; + if (composeFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { + i = m_composeTargetToComposeFuture.erase(i); + } else { + i++; + } + } + if (m_composeTargetToComposeFuture.find(targetHandle) == m_composeTargetToComposeFuture.end()) { + return true; + } + return false; +} diff --git a/stream-servers/PostWorker.h b/stream-servers/PostWorker.h index ccbb3cfe..63a98940 100644 --- a/stream-servers/PostWorker.h +++ b/stream-servers/PostWorker.h @@ -125,6 +125,9 @@ class PostWorker { // With Vulkan swapchain, compose also means to post to the WSI surface. // In this case, don't do anything in the subsequent resource flush. std::optional<uint32_t> m_lastVkComposeColorBuffer = std::nullopt; + std::unordered_map<uint32_t, std::shared_future<void>> m_composeTargetToComposeFuture; + + bool isComposeTargetReady(uint32_t targetHandle); DISALLOW_COPY_AND_ASSIGN(PostWorker); }; diff --git a/stream-servers/RenderControl.cpp b/stream-servers/RenderControl.cpp index 09dbf9c1..cec056fa 100644 --- a/stream-servers/RenderControl.cpp +++ b/stream-servers/RenderControl.cpp @@ -315,14 +315,9 @@ static bool shouldEnableHostComposition() { } static bool shouldEnableVulkan() { - auto supportInfo = - goldfish_vk::VkDecoderGlobalState::get()-> - getHostFeatureSupport(); - bool flagEnabled = - feature_is_enabled(kFeature_Vulkan); // TODO: Restrict further to devices supporting external memory. - return supportInfo.supportsVulkan && - flagEnabled; + return feature_is_enabled(kFeature_Vulkan) && + goldfish_vk::VkDecoderGlobalState::get()->getHostFeatureSupport().supportsVulkan; } static bool shouldEnableDeferredVulkanCommands() { @@ -480,7 +475,7 @@ static EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize) { feature_is_enabled(kFeature_YUV420888toNV21); bool YUVCacheEnabled = feature_is_enabled(kFeature_YUVCache); - bool AsyncUnmapBufferEnabled = false; + bool AsyncUnmapBufferEnabled = feature_is_enabled(kFeature_AsyncComposeSupport); bool vulkanIgnoredHandlesEnabled = shouldEnableVulkan() && feature_is_enabled(kFeature_VulkanIgnoredHandles); bool virtioGpuNextEnabled = @@ -669,9 +664,11 @@ static EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize) { glStr += kHostSideTracing; glStr += " "; - // Async makecurrent support. - // glStr += kAsyncFrameCommands; - // glStr += " "; + if (feature_is_enabled(kFeature_AsyncComposeSupport)) { + // Async makecurrent support. + glStr += kAsyncFrameCommands; + glStr += " "; + } if (feature_is_enabled(kFeature_IgnoreHostOpenGLErrors)) { glStr += kGLESNoHostError; diff --git a/stream-servers/RenderThread.cpp b/stream-servers/RenderThread.cpp index a0a35853..32ca0958 100644 --- a/stream-servers/RenderThread.cpp +++ b/stream-servers/RenderThread.cpp @@ -16,25 +16,24 @@ #include "RenderThread.h" #include "ChannelStream.h" -#include "RingStream.h" #include "FrameBuffer.h" +#include "OpenGLESDispatch/EGLDispatch.h" +#include "OpenGLESDispatch/GLESv1Dispatch.h" +#include "OpenGLESDispatch/GLESv2Dispatch.h" #include "ReadBuffer.h" -#include "RenderControl.h" -#include "RendererImpl.h" #include "RenderChannelImpl.h" +#include "RenderControl.h" #include "RenderThreadInfo.h" - -#include "OpenGLESDispatch/EGLDispatch.h" -#include "OpenGLESDispatch/GLESv2Dispatch.h" -#include "OpenGLESDispatch/GLESv1Dispatch.h" +#include "RendererImpl.h" +#include "RingStream.h" #include "apigen-codec-common/ChecksumCalculatorThreadInfo.h" - -#include "base/System.h" -#include "base/Tracing.h" -#include "base/StreamSerializing.h" #include "base/Lock.h" #include "base/MessageChannel.h" +#include "base/StreamSerializing.h" +#include "base/System.h" +#include "base/Tracing.h" #include "host-common/logging.h" +#include "vulkan/VkCommonOperations.h" #define EMUGL_DEBUG_LEVEL 0 #include "host-common/crash_reporter.h" @@ -286,6 +285,9 @@ intptr_t RenderThread::main() { // Framebuffer initialization is asynchronous, so we need to make sure // it's completely initialized before running any GL commands. FrameBuffer::waitUntilInitialized(); + if (goldfish_vk::getGlobalVkEmulation()) { + tInfo.m_vkDec = std::make_unique<VkDecoder>(); + } // This is the only place where we try loading from snapshot. // But the context bind / restoration will be delayed after receiving @@ -428,9 +430,9 @@ intptr_t RenderThread::main() { // // Note: It's risky to limit Vulkan decoding to one thread, // so we do it outside the limiter - { - last = tInfo.m_vkDec.decode(readBuf.buf(), readBuf.validData(), - ioStream, seqnoPtr); + if (tInfo.m_vkDec) { + last = + tInfo.m_vkDec->decode(readBuf.buf(), readBuf.validData(), ioStream, seqnoPtr); if (last > 0) { readBuf.consume(last); progress = true; diff --git a/stream-servers/RenderThreadInfo.h b/stream-servers/RenderThreadInfo.h index 46e7f997..ecf4c7d9 100644 --- a/stream-servers/RenderThreadInfo.h +++ b/stream-servers/RenderThreadInfo.h @@ -16,18 +16,19 @@ #ifndef _LIB_OPENGL_RENDER_THREAD_INFO_H #define _LIB_OPENGL_RENDER_THREAD_INFO_H -#include "base/Stream.h" +#include <functional> +#include <memory> +#include <unordered_set> + #include "RenderContext.h" +#include "StalePtrRegistry.h" +#include "SyncThread.h" +#include "VkDecoder.h" #include "WindowSurface.h" +#include "base/Stream.h" #include "gles1_dec/GLESv1Decoder.h" #include "gles2_dec/GLESv2Decoder.h" #include "renderControl_dec/renderControl_dec.h" -#include "VkDecoder.h" -#include "StalePtrRegistry.h" -#include "SyncThread.h" - -#include <functional> -#include <unordered_set> typedef uint32_t HandleType; typedef std::unordered_set<HandleType> ThreadContextSet; @@ -62,7 +63,7 @@ struct RenderThreadInfo { GLESv1Decoder m_glDec; GLESv2Decoder m_gl2Dec; renderControl_decoder_context_t m_rcDec; - VkDecoder m_vkDec; + std::unique_ptr<VkDecoder> m_vkDec; // All the contexts that are created by this render thread. // New emulator manages contexts in guest process level, diff --git a/stream-servers/SwapChainStateVk.cpp b/stream-servers/SwapChainStateVk.cpp index a0364b9e..2f5e7890 100644 --- a/stream-servers/SwapChainStateVk.cpp +++ b/stream-servers/SwapChainStateVk.cpp @@ -3,16 +3,75 @@ #include <cinttypes> #include <unordered_set> +#include "host-common/GfxstreamFatalError.h" #include "host-common/logging.h" #include "vulkan/vk_enum_string_helper.h" #include "vulkan/vk_util.h" +using emugl::ABORT_REASON_OTHER; +using emugl::FatalError; + #define SWAPCHAINSTATE_VK_ERROR(fmt, ...) \ do { \ fprintf(stderr, "%s(%s:%d): " fmt "\n", __func__, __FILE__, __LINE__, ##__VA_ARGS__); \ fflush(stderr); \ } while (0) +namespace { + +void swap(SwapchainCreateInfoWrapper& a, SwapchainCreateInfoWrapper& b) { + std::swap(a.mQueueFamilyIndices, b.mQueueFamilyIndices); + std::swap(a.mCreateInfo, b.mCreateInfo); + // The C++ spec guarantees that after std::swap is called, all iterators and references of the + // container remain valid, and the past-the-end iterator is invalidated. Therefore, no need to + // reset the VkSwapchainCreateInfoKHR::pQueueFamilyIndices. +} + +} // namespace + +SwapchainCreateInfoWrapper::SwapchainCreateInfoWrapper(const VkSwapchainCreateInfoKHR& createInfo) + : mCreateInfo(createInfo) { + if (createInfo.pNext) { + GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) + << "VkSwapchainCreateInfoKHR with pNext in the chain is not supported."; + } + + if (createInfo.pQueueFamilyIndices && (createInfo.queueFamilyIndexCount > 0)) { + setQueueFamilyIndices(std::vector<uint32_t>( + createInfo.pQueueFamilyIndices, + createInfo.pQueueFamilyIndices + createInfo.queueFamilyIndexCount)); + } else { + setQueueFamilyIndices({}); + } +} + +SwapchainCreateInfoWrapper::SwapchainCreateInfoWrapper(const SwapchainCreateInfoWrapper& other) + : mCreateInfo(other.mCreateInfo) { + if (other.mCreateInfo.pNext) { + GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) + << "VkSwapchainCreateInfoKHR with pNext in the chain is not supported."; + } + setQueueFamilyIndices(other.mQueueFamilyIndices); +} + +SwapchainCreateInfoWrapper& SwapchainCreateInfoWrapper::operator=( + const SwapchainCreateInfoWrapper& other) { + SwapchainCreateInfoWrapper tmp(other); + swap(*this, tmp); + return *this; +} + +void SwapchainCreateInfoWrapper::setQueueFamilyIndices( + const std::vector<uint32_t>& queueFamilyIndices) { + mQueueFamilyIndices = queueFamilyIndices; + mCreateInfo.queueFamilyIndexCount = static_cast<uint32_t>(mQueueFamilyIndices.size()); + if (mQueueFamilyIndices.empty()) { + mCreateInfo.pQueueFamilyIndices = nullptr; + } else { + mCreateInfo.pQueueFamilyIndices = queueFamilyIndices.data(); + } +} + SwapChainStateVk::SwapChainStateVk(const goldfish_vk::VulkanDispatch &vk, VkDevice vkDevice, const VkSwapchainCreateInfoKHR &swapChainCi) : m_vk(vk), @@ -85,9 +144,9 @@ bool SwapChainStateVk::validateQueueFamilyProperties(const goldfish_vk::VulkanDi return presentSupport; } -SwapChainStateVk::VkSwapchainCreateInfoKHRPtr SwapChainStateVk::createSwapChainCi( - const goldfish_vk::VulkanDispatch &vk, VkSurfaceKHR surface, VkPhysicalDevice physicalDevice, - uint32_t width, uint32_t height, const std::unordered_set<uint32_t> &queueFamilyIndices) { +std::optional<SwapchainCreateInfoWrapper> SwapChainStateVk::createSwapChainCi( + const goldfish_vk::VulkanDispatch& vk, VkSurfaceKHR surface, VkPhysicalDevice physicalDevice, + uint32_t width, uint32_t height, const std::unordered_set<uint32_t>& queueFamilyIndices) { uint32_t formatCount = 0; VK_CHECK( vk.vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formatCount, nullptr)); @@ -124,7 +183,7 @@ SwapChainStateVk::VkSwapchainCreateInfoKHRPtr SwapChainStateVk::createSwapChainC ") with color space(%#" PRIx64 ") not supported.", static_cast<uint64_t>(k_vkFormat), static_cast<uint64_t>(k_vkColorSpace)); - return nullptr; + return std::nullopt; } uint32_t presentModeCount = 0; @@ -137,7 +196,7 @@ SwapChainStateVk::VkSwapchainCreateInfoKHRPtr SwapChainStateVk::createSwapChainC VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; if (!presentModes.count(VK_PRESENT_MODE_FIFO_KHR)) { SWAPCHAINSTATE_VK_ERROR("Fail to create swapchain: FIFO present mode not supported."); - return nullptr; + return std::nullopt; } VkFormatProperties formatProperties = {}; vk.vkGetPhysicalDeviceFormatProperties(physicalDevice, k_vkFormat, &formatProperties); @@ -151,7 +210,7 @@ SwapChainStateVk::VkSwapchainCreateInfoKHRPtr SwapChainStateVk::createSwapChainC "The format %s with the optimal tiling doesn't support VK_FORMAT_FEATURE_BLIT_DST_BIT. " "The supported features are %s.", string_VkFormat(k_vkFormat), string_VkFormatFeatureFlags(formatFeatures).c_str()); - return nullptr; + return std::nullopt; } VkSurfaceCapabilitiesKHR surfaceCaps; VK_CHECK(vk.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &surfaceCaps)); @@ -160,7 +219,7 @@ SwapChainStateVk::VkSwapchainCreateInfoKHRPtr SwapChainStateVk::createSwapChainC "The supported usage flags of the presentable images is %s, and don't contain " "VK_IMAGE_USAGE_TRANSFER_DST_BIT.", string_VkImageUsageFlags(surfaceCaps.supportedUsageFlags).c_str()); - return nullptr; + return std::nullopt; } std::optional<VkExtent2D> maybeExtent = std::nullopt; if (surfaceCaps.currentExtent.width != UINT32_MAX && surfaceCaps.currentExtent.width == width && @@ -176,52 +235,43 @@ SwapChainStateVk::VkSwapchainCreateInfoKHRPtr SwapChainStateVk::createSwapChainC SWAPCHAINSTATE_VK_ERROR("Fail to create swapchain: extent(%" PRIu64 "x%" PRIu64 ") not supported.", static_cast<uint64_t>(width), static_cast<uint64_t>(height)); - return nullptr; + return std::nullopt; } auto extent = maybeExtent.value(); uint32_t imageCount = surfaceCaps.minImageCount + 1; if (surfaceCaps.maxImageCount != 0 && surfaceCaps.maxImageCount < imageCount) { imageCount = surfaceCaps.maxImageCount; } - VkSwapchainCreateInfoKHRPtr swapChainCi( - new VkSwapchainCreateInfoKHR{ - .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, - .pNext = nullptr, - .flags = VkSwapchainCreateFlagsKHR{0}, - .surface = surface, - .minImageCount = imageCount, - .imageFormat = iSurfaceFormat->format, - .imageColorSpace = iSurfaceFormat->colorSpace, - .imageExtent = extent, - .imageArrayLayers = 1, - .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, - .imageSharingMode = VkSharingMode{}, - .queueFamilyIndexCount = 0, - .pQueueFamilyIndices = nullptr, - .preTransform = surfaceCaps.currentTransform, - .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - .presentMode = presentMode, - .clipped = VK_TRUE, - .oldSwapchain = VK_NULL_HANDLE}, - [](VkSwapchainCreateInfoKHR *p) { - if (p->pQueueFamilyIndices != nullptr) { - delete[] p->pQueueFamilyIndices; - } - }); + SwapchainCreateInfoWrapper swapChainCi(VkSwapchainCreateInfoKHR{ + .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + .pNext = nullptr, + .flags = VkSwapchainCreateFlagsKHR{0}, + .surface = surface, + .minImageCount = imageCount, + .imageFormat = iSurfaceFormat->format, + .imageColorSpace = iSurfaceFormat->colorSpace, + .imageExtent = extent, + .imageArrayLayers = 1, + .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, + .imageSharingMode = VkSharingMode{}, + .queueFamilyIndexCount = 0, + .pQueueFamilyIndices = nullptr, + .preTransform = surfaceCaps.currentTransform, + .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + .presentMode = presentMode, + .clipped = VK_TRUE, + .oldSwapchain = VK_NULL_HANDLE}); if (queueFamilyIndices.empty()) { SWAPCHAINSTATE_VK_ERROR("Fail to create swapchain: no Vulkan queue family specified."); - return nullptr; + return std::nullopt; } if (queueFamilyIndices.size() == 1) { - swapChainCi->imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; - swapChainCi->queueFamilyIndexCount = 0; - swapChainCi->pQueueFamilyIndices = nullptr; + swapChainCi.mCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + swapChainCi.setQueueFamilyIndices({}); } else { - swapChainCi->imageSharingMode = VK_SHARING_MODE_CONCURRENT; - swapChainCi->queueFamilyIndexCount = static_cast<uint32_t>(queueFamilyIndices.size()); - uint32_t *pQueueFamilyIndices = new uint32_t[queueFamilyIndices.size()]; - std::copy(queueFamilyIndices.begin(), queueFamilyIndices.end(), pQueueFamilyIndices); - swapChainCi->pQueueFamilyIndices = pQueueFamilyIndices; + swapChainCi.mCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; + swapChainCi.setQueueFamilyIndices( + std::vector<uint32_t>(queueFamilyIndices.begin(), queueFamilyIndices.end())); } return swapChainCi; } diff --git a/stream-servers/SwapChainStateVk.h b/stream-servers/SwapChainStateVk.h index ee50c07c..71066d75 100644 --- a/stream-servers/SwapChainStateVk.h +++ b/stream-servers/SwapChainStateVk.h @@ -4,22 +4,41 @@ #include <functional> #include <memory> #include <optional> +#include <type_traits> #include <unordered_set> #include <vector> #include "vulkan/cereal/common/goldfish_vk_dispatch.h" +struct SwapchainCreateInfoWrapper { + VkSwapchainCreateInfoKHR mCreateInfo; + std::vector<uint32_t> mQueueFamilyIndices; + + SwapchainCreateInfoWrapper(const SwapchainCreateInfoWrapper&); + SwapchainCreateInfoWrapper(SwapchainCreateInfoWrapper&&) = delete; + SwapchainCreateInfoWrapper& operator=(const SwapchainCreateInfoWrapper&); + SwapchainCreateInfoWrapper& operator=(SwapchainCreateInfoWrapper&&) = delete; + + SwapchainCreateInfoWrapper(const VkSwapchainCreateInfoKHR&); + + void setQueueFamilyIndices(const std::vector<uint32_t>& queueFamilyIndices); +}; + +// Assert SwapchainCreateInfoWrapper is a copy only class. +static_assert(std::is_copy_assignable_v<SwapchainCreateInfoWrapper> && + std::is_copy_constructible_v<SwapchainCreateInfoWrapper> && + !std::is_move_constructible_v<SwapchainCreateInfoWrapper> && + !std::is_move_assignable_v<SwapchainCreateInfoWrapper>); + class SwapChainStateVk { public: static std::vector<const char *> getRequiredInstanceExtensions(); static std::vector<const char *> getRequiredDeviceExtensions(); static bool validateQueueFamilyProperties(const goldfish_vk::VulkanDispatch &, VkPhysicalDevice, VkSurfaceKHR, uint32_t queueFamilyIndex); - using VkSwapchainCreateInfoKHRPtr = - std::unique_ptr<VkSwapchainCreateInfoKHR, std::function<void(VkSwapchainCreateInfoKHR *)>>; - static VkSwapchainCreateInfoKHRPtr createSwapChainCi( - const goldfish_vk::VulkanDispatch &, VkSurfaceKHR, VkPhysicalDevice, uint32_t width, - uint32_t height, const std::unordered_set<uint32_t> &queueFamilyIndices); + static std::optional<SwapchainCreateInfoWrapper> createSwapChainCi( + const goldfish_vk::VulkanDispatch&, VkSurfaceKHR, VkPhysicalDevice, uint32_t width, + uint32_t height, const std::unordered_set<uint32_t>& queueFamilyIndices); explicit SwapChainStateVk(const goldfish_vk::VulkanDispatch &, VkDevice, const VkSwapchainCreateInfoKHR &); diff --git a/stream-servers/tests/DisplayVk_unittest.cpp b/stream-servers/tests/DisplayVk_unittest.cpp index 984cff3b..7c36164a 100644 --- a/stream-servers/tests/DisplayVk_unittest.cpp +++ b/stream-servers/tests/DisplayVk_unittest.cpp @@ -129,7 +129,7 @@ class DisplayVkTest : public ::testing::Test { SwapChainStateVk::validateQueueFamilyProperties(*k_vk, device, m_vkSurface, queueFamilyIndex) && SwapChainStateVk::createSwapChainCi(*k_vk, m_vkSurface, device, k_width, - k_height, {queueFamilyIndex}) != nullptr) { + k_height, {queueFamilyIndex})) { maybeSwapChainQueueFamilyIndex = queueFamilyIndex; } if (!maybeCompositorQueueFamilyIndex.has_value() && diff --git a/stream-servers/tests/SwapChainStateVk_unittest.cpp b/stream-servers/tests/SwapChainStateVk_unittest.cpp index f3ed3e6e..819dd22d 100644 --- a/stream-servers/tests/SwapChainStateVk_unittest.cpp +++ b/stream-servers/tests/SwapChainStateVk_unittest.cpp @@ -99,9 +99,8 @@ class SwapChainStateVkTest : public ::testing::Test { *k_vk, device, m_vkSurface, queueFamilyIndex)) { continue; } - if (SwapChainStateVk::createSwapChainCi( - *k_vk, m_vkSurface, device, k_width, k_height, - {queueFamilyIndex}) == nullptr) { + if (!SwapChainStateVk::createSwapChainCi(*k_vk, m_vkSurface, device, k_width, + k_height, {queueFamilyIndex})) { continue; } break; @@ -149,6 +148,6 @@ TEST_F(SwapChainStateVkTest, init) { auto swapChainCi = SwapChainStateVk::createSwapChainCi( *k_vk, m_vkSurface, m_vkPhysicalDevice, k_width, k_height, {m_swapChainQueueFamilyIndex}); - ASSERT_NE(swapChainCi, nullptr); - SwapChainStateVk swapChainState(*k_vk, m_vkDevice, *swapChainCi); + ASSERT_NE(swapChainCi, std::nullopt); + SwapChainStateVk swapChainState(*k_vk, m_vkDevice, swapChainCi->mCreateInfo); }
\ No newline at end of file diff --git a/stream-servers/virtio-gpu-gfxstream-renderer.cpp b/stream-servers/virtio-gpu-gfxstream-renderer.cpp index 3c821e9b..0cb0af6f 100644 --- a/stream-servers/virtio-gpu-gfxstream-renderer.cpp +++ b/stream-servers/virtio-gpu-gfxstream-renderer.cpp @@ -27,12 +27,12 @@ #include "host-common/GfxstreamFatalError.h" #include "host-common/opengles.h" #include "host-common/vm_operations.h" +#include "host-common/linux_types.h" extern "C" { #include "virtio-gpu-gfxstream-renderer.h" #include "drm_fourcc.h" #include "virgl_hw.h" -#include "host-common/virtio_gpu.h" #include "host-common/goldfish_pipe.h" } // extern "C" @@ -586,12 +586,13 @@ public: } } - int createContext(VirtioGpuCtxId handle, uint32_t nlen, const char* name) { + int createContext(VirtioGpuCtxId ctx_id, uint32_t nlen, const char* name, + uint32_t context_init) { AutoLock lock(mLock); - VGPLOG("ctxid: %u len: %u name: %s", handle, nlen, name); + VGPLOG("ctxid: %u len: %u name: %s", ctx_id, nlen, name); auto ops = ensureAndGetServiceOps(); auto hostPipe = ops->guest_open_with_flags( - reinterpret_cast<GoldfishHwPipe*>(handle), + reinterpret_cast<GoldfishHwPipe*>(ctx_id), 0x1 /* is virtio */); if (!hostPipe) { @@ -600,15 +601,15 @@ public: } PipeCtxEntry res = { - handle, // ctxId + ctx_id, // ctxId hostPipe, // hostPipe 0, // fence 0, // AS handle false, // does not have an AS handle }; - VGPLOG("initial host pipe for ctxid %u: %p", handle, hostPipe); - mContexts[handle] = res; + VGPLOG("initial host pipe for ctxid %u: %p", ctx_id, hostPipe); + mContexts[ctx_id] = res; return 0; } @@ -1673,7 +1674,7 @@ VG_EXPORT void pipe_virgl_renderer_resource_unref(uint32_t res_handle) { VG_EXPORT int pipe_virgl_renderer_context_create( uint32_t handle, uint32_t nlen, const char *name) { - return sRenderer()->createContext(handle, nlen, name); + return sRenderer()->createContext(handle, nlen, name, 0); } VG_EXPORT void pipe_virgl_renderer_context_destroy(uint32_t handle) { @@ -1786,6 +1787,11 @@ VG_EXPORT int stream_renderer_resource_unmap(uint32_t res_handle) { return sRenderer()->resourceUnmap(res_handle); } +VG_EXPORT int stream_renderer_create_context(uint32_t ctx_id, uint32_t nlen, const char *name, + uint32_t context_init) { + return sRenderer()->createContext(ctx_id, nlen, name, context_init); +} + VG_EXPORT int stream_renderer_context_create_fence( uint64_t fence_id, uint32_t ctx_id, uint8_t ring_idx) { sRenderer()->contextCreateFence(fence_id, ctx_id, ring_idx); diff --git a/stream-servers/virtio-gpu-gfxstream-renderer.h b/stream-servers/virtio-gpu-gfxstream-renderer.h index 4b714424..922b42ab 100644 --- a/stream-servers/virtio-gpu-gfxstream-renderer.h +++ b/stream-servers/virtio-gpu-gfxstream-renderer.h @@ -126,6 +126,10 @@ VG_EXPORT int stream_renderer_export_blob(uint32_t res_handle, VG_EXPORT int stream_renderer_resource_map(uint32_t res_handle, void** hvaOut, uint64_t* sizeOut); VG_EXPORT int stream_renderer_resource_unmap(uint32_t res_handle); + +VG_EXPORT int stream_renderer_context_create(uint32_t ctx_id, uint32_t nlen, const char *name, + uint32_t context_init); + VG_EXPORT int stream_renderer_context_create_fence( uint64_t fence_id, uint32_t ctx_id, uint8_t ring_idx); diff --git a/stream-servers/vulkan/VkCommonOperations.cpp b/stream-servers/vulkan/VkCommonOperations.cpp index 1a487cd4..fccd26fe 100644 --- a/stream-servers/vulkan/VkCommonOperations.cpp +++ b/stream-servers/vulkan/VkCommonOperations.cpp @@ -368,6 +368,41 @@ static bool getImageFormatExternalMemorySupportInfo( return true; } +// Vulkan driverVersions are bit-shift packs of their dotted versions +// For example, nvidia driverversion 1934229504 unpacks to 461.40 +// note: while this is equivalent to VkPhysicalDeviceDriverProperties.driverInfo on NVIDIA, +// on intel that value is simply "Intel driver". +static std::string decodeDriverVersion(uint32_t vendorId, uint32_t driverVersion) { + std::stringstream result; + switch (vendorId) { + case 0x10DE: { + // Nvidia. E.g. driverVersion = 1934229504(0x734a0000) maps to 461.40 + uint32_t major = driverVersion >> 22; + uint32_t minor = (driverVersion >> 14) & 0xff; + uint32_t build = (driverVersion >> 6) & 0xff; + uint32_t revision = driverVersion & 0x3f; + result << major << '.' << minor << '.' << build << '.' << revision; + break; + } + case 0x8086: { + // Intel. E.g. driverVersion = 1647866(0x1924fa) maps to 100.9466 (27.20.100.9466) + uint32_t high = driverVersion >> 14; + uint32_t low = driverVersion & 0x3fff; + result << high << '.' << low; + break; + } + case 0x002: // amd + default: { + uint32_t major = VK_VERSION_MAJOR(driverVersion); + uint32_t minor = VK_VERSION_MINOR(driverVersion); + uint32_t patch = VK_VERSION_PATCH(driverVersion); + result << major << "." << minor << "." << patch; + break; + } + } + return result.str(); +} + static std::vector<VkEmulation::ImageSupportInfo> getBasicImageSupportList() { std::vector<VkFormat> formats = { // Cover all the gralloc formats @@ -483,7 +518,8 @@ VkEmulation* createGlobalVkEmulation(VulkanDispatch* vk) { uint32_t extCount = 0; gvk->vkEnumerateInstanceExtensionProperties(nullptr, &extCount, nullptr); - std::vector<VkExtensionProperties> exts(extCount); + std::vector<VkExtensionProperties>& exts = sVkEmulation->instanceExtensions; + exts.resize(extCount); gvk->vkEnumerateInstanceExtensionProperties(nullptr, &extCount, exts.data()); bool externalMemoryCapabilitiesSupported = @@ -599,6 +635,8 @@ VkEmulation* createGlobalVkEmulation(VulkanDispatch* vk) { } } + sVkEmulation->vulkanInstanceVersion = appInfo.apiVersion; + sVkEmulation->instanceSupportsExternalMemoryCapabilities = externalMemoryCapabilitiesSupported; sVkEmulation->instanceSupportsMoltenVK = moltenVKSupported; @@ -662,7 +700,8 @@ VkEmulation* createGlobalVkEmulation(VulkanDispatch* vk) { uint32_t deviceExtensionCount = 0; ivk->vkEnumerateDeviceExtensionProperties( physdevs[i], nullptr, &deviceExtensionCount, nullptr); - std::vector<VkExtensionProperties> deviceExts(deviceExtensionCount); + std::vector<VkExtensionProperties>& deviceExts = deviceInfos[i].extensions; + deviceExts.resize(deviceExtensionCount); ivk->vkEnumerateDeviceExtensionProperties( physdevs[i], nullptr, &deviceExtensionCount, deviceExts.data()); @@ -670,27 +709,70 @@ VkEmulation* createGlobalVkEmulation(VulkanDispatch* vk) { deviceInfos[i].glInteropSupported = 0; // set later if (sVkEmulation->instanceSupportsExternalMemoryCapabilities) { - deviceInfos[i].supportsExternalMemory = extensionsSupported( - deviceExts, externalMemoryDeviceExtNames); + deviceInfos[i].supportsExternalMemory = + extensionsSupported(deviceExts, externalMemoryDeviceExtNames); deviceInfos[i].supportsIdProperties = sVkEmulation->getPhysicalDeviceProperties2Func != nullptr; + deviceInfos[i].supportsDriverProperties = + extensionsSupported(deviceExts, {VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME}) || + (deviceInfos[i].physdevProps.apiVersion >= VK_API_VERSION_1_2); + if (!sVkEmulation->getPhysicalDeviceProperties2Func) { fprintf(stderr, "%s: warning: device claims to support ID properties " "but vkGetPhysicalDeviceProperties2 could not be found\n", __func__); } } - if (deviceInfos[i].supportsIdProperties) { - VkPhysicalDeviceIDPropertiesKHR idProps = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, nullptr, + if (sVkEmulation->getPhysicalDeviceProperties2Func) { + VkPhysicalDeviceProperties2 deviceProps = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + }; + VkPhysicalDeviceIDProperties idProps = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, }; - VkPhysicalDeviceProperties2KHR propsWithId = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, &idProps, + VkPhysicalDeviceDriverPropertiesKHR driverProps = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, }; + + auto devicePropsChain = vk_make_chain_iterator(&deviceProps); + + if (deviceInfos[i].supportsIdProperties) { + vk_append_struct(&devicePropsChain, &idProps); + } + + if (deviceInfos[i].supportsDriverProperties) { + vk_append_struct(&devicePropsChain, &driverProps); + } + sVkEmulation->getPhysicalDeviceProperties2Func( physdevs[i], - &propsWithId); - deviceInfos[i].idProps = idProps; + &deviceProps); + + deviceInfos[i].idProps = vk_make_orphan_copy(idProps); + + std::stringstream driverVendorBuilder; + driverVendorBuilder << "Vendor " << std::hex << std::setfill('0') << std::showbase + << deviceInfos[i].physdevProps.vendorID; + + std::string decodedDriverVersion = decodeDriverVersion( + deviceInfos[i].physdevProps.vendorID, + deviceInfos[i].physdevProps.driverVersion); + + std::stringstream driverVersionBuilder; + driverVersionBuilder << "Driver Version " << std::hex << std::setfill('0') + << std::showbase << deviceInfos[i].physdevProps.driverVersion + << " Decoded As " << decodedDriverVersion; + + std::string driverVendor = driverVendorBuilder.str(); + std::string driverVersion = driverVersionBuilder.str(); + if (deviceInfos[i].supportsDriverProperties && driverProps.driverID) { + driverVendor = std::string{driverProps.driverName} + " (" + driverVendor + ")"; + driverVersion = std::string{driverProps.driverInfo} + " (" + + string_VkDriverId(driverProps.driverID) + " " + driverVersion + ")"; + } + + deviceInfos[i].driverVendor = driverVendor; + deviceInfos[i].driverVersion = driverVersion; } deviceInfos[i].hasSamplerYcbcrConversionExtension = @@ -2532,8 +2614,9 @@ static std::tuple<VkCommandBuffer, VkFence> allocateQueueTransferCommandBuffer_l if (res == VK_NOT_READY) { continue; } - GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) - << "Invalid fence state: " << static_cast<int>(res); + // We either have a device lost, or an invalid fence state. For the device lost case, + // VK_CHECK will ensure we capture the relevant streams. + VK_CHECK(res); } VkCommandBuffer commandBuffer; VkCommandBufferAllocateInfo allocateInfo = { diff --git a/stream-servers/vulkan/VkCommonOperations.h b/stream-servers/vulkan/VkCommonOperations.h index 235d0e53..5e0b96bc 100644 --- a/stream-servers/vulkan/VkCommonOperations.h +++ b/stream-servers/vulkan/VkCommonOperations.h @@ -140,10 +140,13 @@ struct VkEmulation { bool hasComputeQueueFamily = false; bool supportsExternalMemory = false; bool supportsIdProperties = false; + bool supportsDriverProperties = false; bool hasSamplerYcbcrConversionExtension = false; bool supportsSamplerYcbcrConversion = false; bool glInteropSupported = false; + std::vector<VkExtensionProperties> extensions; + std::vector<uint32_t> graphicsQueueFamilyIndices; std::vector<uint32_t> computeQueueFamilyIndices; @@ -151,6 +154,9 @@ struct VkEmulation { VkPhysicalDeviceMemoryProperties memProps; VkPhysicalDeviceIDPropertiesKHR idProps; + std::string driverVendor; + std::string driverVersion; + PFN_vkGetImageMemoryRequirements2KHR getImageMemoryRequirements2Func = nullptr; PFN_vkGetBufferMemoryRequirements2KHR getBufferMemoryRequirements2Func = nullptr; @@ -296,6 +302,10 @@ struct VkEmulation { // Track what is supported on whatever device was selected. DeviceSupportInfo deviceInfo; + // Track additional vulkan diagnostics + uint32_t vulkanInstanceVersion; + std::vector<VkExtensionProperties> instanceExtensions; + // A single staging buffer to perform most transfers to/from OpenGL on the // host. It is shareable across instances. The memory is shareable but the // buffer is not; other users need to create buffers that diff --git a/stream-servers/vulkan/cereal/common/vk_struct_id.h b/stream-servers/vulkan/cereal/common/vk_struct_id.h index 39193569..8dac8366 100644 --- a/stream-servers/vulkan/cereal/common/vk_struct_id.h +++ b/stream-servers/vulkan/cereal/common/vk_struct_id.h @@ -54,6 +54,9 @@ REGISTER_VK_STRUCT_ID(VkPhysicalDeviceImageFormatInfo2, VK_STRUCTURE_TYPE_PHYSIC REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalImageFormatInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO); REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES); REGISTER_VK_STRUCT_ID(VkPhysicalDeviceFeatures2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2); +REGISTER_VK_STRUCT_ID(VkPhysicalDeviceProperties2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2); +REGISTER_VK_STRUCT_ID(VkPhysicalDeviceIDProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES); +REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDriverProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES); REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT); REGISTER_VK_STRUCT_ID(VkSemaphoreTypeCreateInfoKHR, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR) REGISTER_VK_STRUCT_ID(VkTimelineSemaphoreSubmitInfoKHR, VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR) diff --git a/test_properties.cmake b/test_properties.cmake new file mode 100644 index 00000000..e42f544f --- /dev/null +++ b/test_properties.cmake @@ -0,0 +1,9 @@ +# This file is executed by CTest prior to running tests +# It can be used to set extra properties on tests. +# +# Example: +# set_tests_properties(MyTestSuite.SomeTest PROPERTIES LABELS foobar) +# +# For this to work: +# 1. Use gtest_discover_tests() to add the test targets +# 2. Call the set_test_include_files() macro at the end of each CMakeLists.txt that defines tests |