From 63b0f441f1f493f8ecc6b135072b14bde07715e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Jastrz=C4=99bski?= Date: Tue, 21 Mar 2023 17:06:15 +0100 Subject: [PATCH] Add external semaphore tests. (#1645) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add external semaphore tests. Added basic test to check the functionality of cl_ext_external_semaphore_test extension. Tests rely on Vulkan API as the producer of the external semaphore functionality. The Vulkan wrapper has been copied from the Vulkan CTS tests and minor changes have been introduced. A separate copy of the Vulkan wrapper is for breaking any dependencies between different CTS modules and thus make the build system simpler. Signed-off-by: Paweł Jastrzębski * Fix clang-format Signed-off-by: Paweł Jastrzębski * Move vulkan wrapper to a separate library. Vulkan wrapper is extracted as a separate module and can be used in different CTS tests as a shared library. Signed-off-by: Paweł Jastrzębski * Add cl_ext_external_samaphore tests based on cl_khr_semaphore tests. Added cl_khr_semaphore adjusted to creating semaphores in Vulkan context and importing them through export semaphore functionality in OpenCL (cl_ext_external_samaphore). Signed-off-by: Paweł Jastrzębski * Cleanup. Signed-off-by: Paweł Jastrzębski * Fix build issues. * Add missing directories for build cl_ext_external_semaphore. Signed-off-by: Paweł Jastrzębski * Set Vulkan lib directory. Signed-off-by: Paweł Jastrzębski * Change extension directory name. Changed extensions directory name from cl_ext_external_semaphore to cl_khr_external_semaphore. Signed-off-by: Paweł Jastrzębski * Remove unneeded compile options. Removed VK_USE_PLATFORM_WIN32_KHR option from cl_khr_external_semaphore compilation arguments. Signed-off-by: Paweł Jastrzębski --------- Signed-off-by: Paweł Jastrzębski --- test_conformance/CMakeLists.txt | 1 + .../common/vulkan_wrapper/CMakeLists.txt | 69 + .../vulkan_wrapper}/opencl_vulkan_wrapper.cpp | 7 +- .../vulkan_wrapper}/opencl_vulkan_wrapper.hpp | 3 +- .../vulkan_wrapper}/vulkan_api_list.hpp | 2 +- .../vulkan_wrapper}/vulkan_list_map.cpp | 0 .../vulkan_wrapper}/vulkan_list_map.hpp | 0 .../vulkan_wrapper}/vulkan_utility.cpp | 0 .../vulkan_wrapper}/vulkan_utility.hpp | 0 .../vulkan_wrapper}/vulkan_wrapper.cpp | 0 .../vulkan_wrapper}/vulkan_wrapper.hpp | 0 .../vulkan_wrapper}/vulkan_wrapper_types.hpp | 926 +++++------ test_conformance/extensions/CMakeLists.txt | 3 + .../cl_khr_external_semaphore/CMakeLists.txt | 28 + .../cl_khr_external_semaphore/main.cpp | 46 + .../cl_khr_external_semaphore/procs.h | 82 + .../test_external_semaphore.cpp | 1350 +++++++++++++++++ test_conformance/vulkan/CMakeLists.txt | 14 +- .../vulkan_interop_common.cpp | 0 .../vulkan_interop_common.hpp | 0 20 files changed, 2056 insertions(+), 475 deletions(-) create mode 100644 test_conformance/common/vulkan_wrapper/CMakeLists.txt rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/opencl_vulkan_wrapper.cpp (99%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/opencl_vulkan_wrapper.hpp (98%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_api_list.hpp (99%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_list_map.cpp (100%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_list_map.hpp (100%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_utility.cpp (100%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_utility.hpp (100%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_wrapper.cpp (100%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_wrapper.hpp (100%) rename test_conformance/{vulkan/vulkan_interop_common => common/vulkan_wrapper}/vulkan_wrapper_types.hpp (97%) create mode 100644 test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt create mode 100644 test_conformance/extensions/cl_khr_external_semaphore/main.cpp create mode 100644 test_conformance/extensions/cl_khr_external_semaphore/procs.h create mode 100644 test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp rename test_conformance/vulkan/{vulkan_interop_common => }/vulkan_interop_common.cpp (100%) rename test_conformance/vulkan/{vulkan_interop_common => }/vulkan_interop_common.hpp (100%) diff --git a/test_conformance/CMakeLists.txt b/test_conformance/CMakeLists.txt index 81d980ef..1f1970af 100644 --- a/test_conformance/CMakeLists.txt +++ b/test_conformance/CMakeLists.txt @@ -53,6 +53,7 @@ add_subdirectory( device_timer ) add_subdirectory( spirv_new ) add_subdirectory( spir ) if(VULKAN_IS_SUPPORTED) + add_subdirectory( common/vulkan_wrapper ) add_subdirectory( vulkan ) endif() diff --git a/test_conformance/common/vulkan_wrapper/CMakeLists.txt b/test_conformance/common/vulkan_wrapper/CMakeLists.txt new file mode 100644 index 00000000..c647b4b6 --- /dev/null +++ b/test_conformance/common/vulkan_wrapper/CMakeLists.txt @@ -0,0 +1,69 @@ +set(VULKAN_WRAPPER_SOURCES + vulkan_wrapper.cpp + opencl_vulkan_wrapper.cpp + vulkan_utility.cpp + vulkan_list_map.cpp +) + +# needed by Vulkan wrapper to compile +add_cxx_flag_if_supported(-Wmisleading-indentation) +add_cxx_flag_if_supported(-Wno-narrowing) +add_cxx_flag_if_supported(-Wno-format) +add_cxx_flag_if_supported(-Wno-error) +add_cxx_flag_if_supported(-Wno-error=cpp) # Allow #warning directive +add_cxx_flag_if_supported(-Wno-error=unknown-pragmas) # Issue #785 +add_cxx_flag_if_supported(-Wno-error=asm-operand-widths) # Issue #784 +add_cxx_flag_if_supported(-Wno-unused-variable) +add_cxx_flag_if_supported(-Wno-error=terminate) +add_cxx_flag_if_supported(-Wno-error=unused-function) +add_cxx_flag_if_supported(-Wno-error=return-type) + +link_directories(${CLConform_VULKAN_LIBRARIES_DIR}) + +list(APPEND CLConform_INCLUDE_DIR ${VULKAN_INCLUDE_DIR}) + +add_library(vulkan_wrapper STATIC ${VULKAN_WRAPPER_SOURCES}) + +if(ANDROID) + target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_ANDROID_KHR) +elseif(WIN32) + target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_WIN32_KHR) +elseif(APPLE) + target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_METAL_EXT) +elseif(UNIX) + # Variable taken from Vulkan samples, commented out due to lack of WSI + # Choose WSI based on VKB_WSI_SELECTION + #if (VKB_WSI_SELECTION STREQUAL XCB OR VKB_WSI_SELECTION STREQUAL XLIB OR VKB_WSI_SELECTION STREQUAL WAYLAND) + # find_package(PkgConfig REQUIRED) + #endif() + #if (VKB_WSI_SELECTION STREQUAL XCB) + # pkg_check_modules(XCB xcb REQUIRED) + # if (XCB_FOUND) + # target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_XCB_KHR) + # endif() + #elseif (VKB_WSI_SELECTION STREQUAL XLIB) + # pkg_check_modules(X11 x11 REQUIRED) + # if (X11_FOUND) + # target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_XLIB_KHR) + # endif() + #elseif (VKB_WSI_SELECTION STREQUAL WAYLAND) + # pkg_check_modules(WAYLAND wayland-client REQUIRED) + # if (WAYLAND_FOUND) + # target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_WAYLAND_KHR) + # endif() + #elseif (VKB_WSI_SELECTION STREQUAL D2D) + # set(DIRECT_TO_DISPLAY TRUE) + # set(DIRECT_TO_DISPLAY TRUE PARENT_SCOPE) + # target_compile_definitions(vulkan_wrapper PUBLIC VK_USE_PLATFORM_DISPLAY_KHR) + #else() + # message(FATAL_ERROR "Unknown WSI") + #endif() +endif() + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + +include_directories (${CLConform_INCLUDE_DIR}) + +if (NOT WIN32) +target_link_libraries(vulkan_wrapper dl) +endif() diff --git a/test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.cpp b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp similarity index 99% rename from test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.cpp rename to test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp index 9d9a6601..0a459e97 100644 --- a/test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.cpp +++ b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp @@ -831,7 +831,7 @@ clExternalSemaphore::clExternalSemaphore( } } -clExternalSemaphore::~clExternalSemaphore() +clExternalSemaphore::~clExternalSemaphore() noexcept(false) { cl_int err = clReleaseSemaphoreKHRptr(m_externalSemaphore); if (err != CL_SUCCESS) @@ -851,3 +851,8 @@ void clExternalSemaphore::wait(cl_command_queue cmd_queue) clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &m_externalSemaphore, NULL, 0, NULL, NULL); } + +cl_semaphore_khr &clExternalSemaphore::getCLSemaphore() +{ + return m_externalSemaphore; +} diff --git a/test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.hpp b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp similarity index 98% rename from test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.hpp rename to test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp index d9f8dccb..5143332d 100644 --- a/test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.hpp +++ b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp @@ -120,9 +120,10 @@ public: const VulkanSemaphore &deviceSemaphore, cl_context context, VulkanExternalSemaphoreHandleType externalSemaphoreHandleType, cl_device_id deviceId); - virtual ~clExternalSemaphore(); + virtual ~clExternalSemaphore() noexcept(false); void signal(cl_command_queue command_queue); void wait(cl_command_queue command_queue); + cl_semaphore_khr &getCLSemaphore(); // operator openclExternalSemaphore_t() const; }; diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_api_list.hpp b/test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp similarity index 99% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_api_list.hpp rename to test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp index 017aefd2..c62a71e1 100644 --- a/test_conformance/vulkan/vulkan_interop_common/vulkan_api_list.hpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp @@ -161,7 +161,7 @@ #define vkCreateImage _vkCreateImage #define vkGetImageMemoryRequirements _vkGetImageMemoryRequirements #define vkDestroyImage _vkDestroyImage -#define vkDestroyBuffe _vkDestroyBuffer +#define vkDestroyBuffer _vkDestroyBuffer #define vkDestroyPipeline _vkDestroyPipeline #define vkDestroyShaderModule _vkDestroyShaderModule #define vkGetPhysicalDeviceMemoryProperties _vkGetPhysicalDeviceMemoryProperties diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp b/test_conformance/common/vulkan_wrapper/vulkan_list_map.cpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp rename to test_conformance/common/vulkan_wrapper/vulkan_list_map.cpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.hpp b/test_conformance/common/vulkan_wrapper/vulkan_list_map.hpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.hpp rename to test_conformance/common/vulkan_wrapper/vulkan_list_map.hpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_utility.cpp b/test_conformance/common/vulkan_wrapper/vulkan_utility.cpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_utility.cpp rename to test_conformance/common/vulkan_wrapper/vulkan_utility.cpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_utility.hpp b/test_conformance/common/vulkan_wrapper/vulkan_utility.hpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_utility.hpp rename to test_conformance/common/vulkan_wrapper/vulkan_utility.hpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper.cpp b/test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper.cpp rename to test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper.hpp b/test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper.hpp rename to test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper_types.hpp b/test_conformance/common/vulkan_wrapper/vulkan_wrapper_types.hpp similarity index 97% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper_types.hpp rename to test_conformance/common/vulkan_wrapper/vulkan_wrapper_types.hpp index 359bcae4..2473a1d7 100644 --- a/test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper_types.hpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_wrapper_types.hpp @@ -1,463 +1,463 @@ -// -// Copyright (c) 2022 The Khronos Group Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -#ifndef _vulkan_wrapper_types_hpp_ -#define _vulkan_wrapper_types_hpp_ - -#include - -#define VULKAN_MIN_BUFFER_OFFSET_COPY_ALIGNMENT 4 -#define VULKAN_REMAINING_MIP_LEVELS VK_REMAINING_MIP_LEVELS -#define VULKAN_REMAINING_ARRAY_LAYERS VK_REMAINING_ARRAY_LAYERS - -class VulkanInstance; -class VulkanPhysicalDevice; -class VulkanMemoryHeap; -class VulkanMemoryType; -class VulkanQueueFamily; -class VulkanDevice; -class VulkanQueue; -class VulkanDescriptorSetLayoutBinding; -class VulkanDescriptorSetLayout; -class VulkanPipelineLayout; -class VulkanShaderModule; -class VulkanPipeline; -class VulkanComputePipeline; -class VulkanDescriptorPool; -class VulkanDescriptorSet; -class VulkanCommandPool; -class VulkanCommandBuffer; -class VulkanBuffer; -class VulkanOffset3D; -class VulkanExtent3D; -class VulkanImage; -class VulkanImage2D; -class VulkanImageView; -class VulkanDeviceMemory; -class VulkanSemaphore; - -class VulkanPhysicalDeviceList; -class VulkanMemoryHeapList; -class VulkanMemoryTypeList; -class VulkanQueueFamilyList; -class VulkanQueueFamilyToQueueCountMap; -class VulkanQueueFamilyToQueueListMap; -class VulkanQueueList; -class VulkanCommandBufferList; -class VulkanDescriptorSetLayoutList; -class VulkanBufferList; -class VulkanImage2DList; -class VulkanImageViewList; -class VulkanDeviceMemoryList; -class VulkanSemaphoreList; - -enum VulkanQueueFlag -{ - VULKAN_QUEUE_FLAG_GRAPHICS = VK_QUEUE_GRAPHICS_BIT, - VULKAN_QUEUE_FLAG_COMPUTE = VK_QUEUE_COMPUTE_BIT, - VULKAN_QUEUE_FLAG_TRANSFER = VK_QUEUE_TRANSFER_BIT, - VULKAN_QUEUE_FLAG_MASK_ALL = VULKAN_QUEUE_FLAG_GRAPHICS - | VULKAN_QUEUE_FLAG_COMPUTE | VULKAN_QUEUE_FLAG_TRANSFER -}; - -enum VulkanDescriptorType -{ - VULKAN_DESCRIPTOR_TYPE_SAMPLER = VK_DESCRIPTOR_TYPE_SAMPLER, - VULKAN_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - VULKAN_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, - VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, - VULKAN_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, - VULKAN_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, - VULKAN_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - VULKAN_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, - VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, - VULKAN_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, -}; - -enum VulkanShaderStage -{ - VULKAN_SHADER_STAGE_VERTEX = VK_SHADER_STAGE_VERTEX_BIT, - VULKAN_SHADER_STAGE_FRAGMENT = VK_SHADER_STAGE_FRAGMENT_BIT, - VULKAN_SHADER_STAGE_COMPUTE = VK_SHADER_STAGE_COMPUTE_BIT, - VULKAN_SHADER_STAGE_ALL_GRAPHICS = VK_SHADER_STAGE_ALL_GRAPHICS, - VULKAN_SHADER_STAGE_ALL = VK_SHADER_STAGE_ALL -}; - -enum VulkanPipelineBindPoint -{ - VULKAN_PIPELINE_BIND_POINT_GRAPHICS = VK_PIPELINE_BIND_POINT_GRAPHICS, - VULKAN_PIPELINE_BIND_POINT_COMPUTE = VK_PIPELINE_BIND_POINT_COMPUTE -}; - -enum VulkanMemoryTypeProperty -{ - VULKAN_MEMORY_TYPE_PROPERTY_NONE = 0, - VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL = - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_COHERENT = - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT - | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED = - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT - | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, - VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED_COHERENT = - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT - | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_COHERENT = - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT - | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT - | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED = - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT - | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT - | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, - VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED_COHERENT = - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT - | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT - | VK_MEMORY_PROPERTY_HOST_CACHED_BIT - | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT -}; - -enum VulkanMemoryHeapFlag -{ - VULKAN_MEMORY_HEAP_FLAG_NONE = 0, - VULKAN_MEMORY_HEAP_FLAG_DEVICE_LOCAL = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT -}; - -enum VulkanExternalMemoryHandleType -{ - VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE = 0, - VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, - VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT = - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, - VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, - VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT = - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR - | VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR -}; - -enum VulkanExternalSemaphoreHandleType -{ - VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE = 0, - VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, - VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT = - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, - VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, - VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT = - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR - | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR -}; - -enum VulkanBufferUsage -{ - VULKAN_BUFFER_USAGE_TRANSFER_SRC = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - VULKAN_BUFFER_USAGE_TRANSFER_DST = VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VULKAN_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER = - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, - VULKAN_BUFFER_USAGE_STORAGE_TEXEL_BUFFER = - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, - VULKAN_BUFFER_USAGE_UNIFORM_BUFFER = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - VULKAN_BUFFER_USAGE_STORAGE_BUFFER = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VULKAN_BUFFER_USAGE_INDEX_BUFFER = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, - VULKAN_BUFFER_USAGE_VERTEX_BUFFER = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, - VULKAN_BUFFER_USAGE_INDIRECT_BUFFER = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, - VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST = - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT - | VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VULKAN_BUFFER_USAGE_UNIFORM_BUFFER_TRANSFER_SRC_DST = - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT - | VK_BUFFER_USAGE_TRANSFER_DST_BIT, -}; - -enum VulkanSharingMode -{ - VULKAN_SHARING_MODE_EXCLUSIVE = VK_SHARING_MODE_EXCLUSIVE, - VULKAN_SHARING_MODE_CONCURRENT = VK_SHARING_MODE_CONCURRENT -}; - -enum VulkanImageType -{ - VULKAN_IMAGE_TYPE_1D = VK_IMAGE_TYPE_1D, - VULKAN_IMAGE_TYPE_2D = VK_IMAGE_TYPE_2D, - VULKAN_IMAGE_TYPE_3D = VK_IMAGE_TYPE_3D -}; - -enum VulkanFormat -{ - VULKAN_FORMAT_UNDEFINED = VK_FORMAT_UNDEFINED, - VULKAN_FORMAT_R4G4_UNORM_PACK8 = VK_FORMAT_R4G4_UNORM_PACK8, - VULKAN_FORMAT_R4G4B4A4_UNORM_PACK16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, - VULKAN_FORMAT_B4G4R4A4_UNORM_PACK16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, - VULKAN_FORMAT_R5G6B5_UNORM_PACK16 = VK_FORMAT_R5G6B5_UNORM_PACK16, - VULKAN_FORMAT_B5G6R5_UNORM_PACK16 = VK_FORMAT_B5G6R5_UNORM_PACK16, - VULKAN_FORMAT_R5G5B5A1_UNORM_PACK16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, - VULKAN_FORMAT_B5G5R5A1_UNORM_PACK16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, - VULKAN_FORMAT_A1R5G5B5_UNORM_PACK16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, - VULKAN_FORMAT_R8_UNORM = VK_FORMAT_R8_UNORM, - VULKAN_FORMAT_R8_SNORM = VK_FORMAT_R8_SNORM, - VULKAN_FORMAT_R8_USCALED = VK_FORMAT_R8_USCALED, - VULKAN_FORMAT_R8_SSCALED = VK_FORMAT_R8_SSCALED, - VULKAN_FORMAT_R8_UINT = VK_FORMAT_R8_UINT, - VULKAN_FORMAT_R8_SINT = VK_FORMAT_R8_SINT, - VULKAN_FORMAT_R8_SRGB = VK_FORMAT_R8_SRGB, - VULKAN_FORMAT_R8G8_SNORM = VK_FORMAT_R8G8_SNORM, - VULKAN_FORMAT_R8G8_UNORM = VK_FORMAT_R8G8_UNORM, - VULKAN_FORMAT_R8G8_USCALED = VK_FORMAT_R8G8_USCALED, - VULKAN_FORMAT_R8G8_SSCALED = VK_FORMAT_R8G8_SSCALED, - VULKAN_FORMAT_R8G8_UINT = VK_FORMAT_R8G8_UINT, - VULKAN_FORMAT_R8G8_SINT = VK_FORMAT_R8G8_SINT, - VULKAN_FORMAT_R8G8_SRGB = VK_FORMAT_R8G8_SRGB, - VULKAN_FORMAT_R8G8B8_UNORM = VK_FORMAT_R8G8B8_UNORM, - VULKAN_FORMAT_R8G8B8_SNORM = VK_FORMAT_R8G8B8_SNORM, - VULKAN_FORMAT_R8G8B8_USCALED = VK_FORMAT_R8G8B8_USCALED, - VULKAN_FORMAT_R8G8B8_SSCALED = VK_FORMAT_R8G8B8_SSCALED, - VULKAN_FORMAT_R8G8B8_UINT = VK_FORMAT_R8G8B8_UINT, - VULKAN_FORMAT_R8G8B8_SINT = VK_FORMAT_R8G8B8_SINT, - VULKAN_FORMAT_R8G8B8_SRGB = VK_FORMAT_R8G8B8_SRGB, - VULKAN_FORMAT_B8G8R8_UNORM = VK_FORMAT_B8G8R8_UNORM, - VULKAN_FORMAT_B8G8R8_SNORM = VK_FORMAT_B8G8R8_SNORM, - VULKAN_FORMAT_B8G8R8_USCALED = VK_FORMAT_B8G8R8_USCALED, - VULKAN_FORMAT_B8G8R8_SSCALED = VK_FORMAT_B8G8R8_SSCALED, - VULKAN_FORMAT_B8G8R8_UINT = VK_FORMAT_B8G8R8_UINT, - VULKAN_FORMAT_B8G8R8_SINT = VK_FORMAT_B8G8R8_SINT, - VULKAN_FORMAT_B8G8R8_SRGB = VK_FORMAT_B8G8R8_SRGB, - VULKAN_FORMAT_R8G8B8A8_UNORM = VK_FORMAT_R8G8B8A8_UNORM, - VULKAN_FORMAT_R8G8B8A8_SNORM = VK_FORMAT_R8G8B8A8_SNORM, - VULKAN_FORMAT_R8G8B8A8_USCALED = VK_FORMAT_R8G8B8A8_USCALED, - VULKAN_FORMAT_R8G8B8A8_SSCALED = VK_FORMAT_R8G8B8A8_SSCALED, - VULKAN_FORMAT_R8G8B8A8_UINT = VK_FORMAT_R8G8B8A8_UINT, - VULKAN_FORMAT_R8G8B8A8_SINT = VK_FORMAT_R8G8B8A8_SINT, - VULKAN_FORMAT_R8G8B8A8_SRGB = VK_FORMAT_R8G8B8A8_SRGB, - VULKAN_FORMAT_B8G8R8A8_UNORM = VK_FORMAT_B8G8R8A8_UNORM, - VULKAN_FORMAT_B8G8R8A8_SNORM = VK_FORMAT_B8G8R8A8_SNORM, - VULKAN_FORMAT_B8G8R8A8_USCALED = VK_FORMAT_B8G8R8A8_USCALED, - VULKAN_FORMAT_B8G8R8A8_SSCALED = VK_FORMAT_B8G8R8A8_SSCALED, - VULKAN_FORMAT_B8G8R8A8_UINT = VK_FORMAT_B8G8R8A8_UINT, - VULKAN_FORMAT_B8G8R8A8_SINT = VK_FORMAT_B8G8R8A8_SINT, - VULKAN_FORMAT_B8G8R8A8_SRGB = VK_FORMAT_B8G8R8A8_SRGB, - VULKAN_FORMAT_A8B8G8R8_UNORM_PACK32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, - VULKAN_FORMAT_A8B8G8R8_SNORM_PACK32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, - VULKAN_FORMAT_A8B8G8R8_USCALED_PACK32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, - VULKAN_FORMAT_A8B8G8R8_SSCALED_PACK32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, - VULKAN_FORMAT_A8B8G8R8_UINT_PACK32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, - VULKAN_FORMAT_A8B8G8R8_SINT_PACK32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, - VULKAN_FORMAT_A8B8G8R8_SRGB_PACK32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, - VULKAN_FORMAT_A2R10G10B10_UNORM_PACK32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, - VULKAN_FORMAT_A2R10G10B10_SNORM_PACK32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, - VULKAN_FORMAT_A2R10G10B10_USCALED_PACK32 = - VK_FORMAT_A2R10G10B10_USCALED_PACK32, - VULKAN_FORMAT_A2R10G10B10_SSCALED_PACK32 = - VK_FORMAT_A2R10G10B10_SSCALED_PACK32, - VULKAN_FORMAT_A2R10G10B10_UINT_PACK32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, - VULKAN_FORMAT_A2R10G10B10_SINT_PACK32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, - VULKAN_FORMAT_A2B10G10R10_UNORM_PACK32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, - VULKAN_FORMAT_A2B10G10R10_SNORM_PACK32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, - VULKAN_FORMAT_A2B10G10R10_USCALED_PACK32 = - VK_FORMAT_A2B10G10R10_USCALED_PACK32, - VULKAN_FORMAT_A2B10G10R10_SSCALED_PACK32 = - VK_FORMAT_A2B10G10R10_SSCALED_PACK32, - VULKAN_FORMAT_A2B10G10R10_UINT_PACK32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, - VULKAN_FORMAT_A2B10G10R10_SINT_PACK32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, - VULKAN_FORMAT_R16_UNORM = VK_FORMAT_R16_UNORM, - VULKAN_FORMAT_R16_SNORM = VK_FORMAT_R16_SNORM, - VULKAN_FORMAT_R16_USCALED = VK_FORMAT_R16_USCALED, - VULKAN_FORMAT_R16_SSCALED = VK_FORMAT_R16_SSCALED, - VULKAN_FORMAT_R16_UINT = VK_FORMAT_R16_UINT, - VULKAN_FORMAT_R16_SINT = VK_FORMAT_R16_SINT, - VULKAN_FORMAT_R16_SFLOAT = VK_FORMAT_R16_SFLOAT, - VULKAN_FORMAT_R16G16_UNORM = VK_FORMAT_R16G16_UNORM, - VULKAN_FORMAT_R16G16_SNORM = VK_FORMAT_R16G16_SNORM, - VULKAN_FORMAT_R16G16_USCALED = VK_FORMAT_R16G16_USCALED, - VULKAN_FORMAT_R16G16_SSCALED = VK_FORMAT_R16G16_SSCALED, - VULKAN_FORMAT_R16G16_UINT = VK_FORMAT_R16G16_UINT, - VULKAN_FORMAT_R16G16_SINT = VK_FORMAT_R16G16_SINT, - VULKAN_FORMAT_R16G16_SFLOAT = VK_FORMAT_R16G16_SFLOAT, - VULKAN_FORMAT_R16G16B16_UNORM = VK_FORMAT_R16G16B16_UNORM, - VULKAN_FORMAT_R16G16B16_SNORM = VK_FORMAT_R16G16B16_SNORM, - VULKAN_FORMAT_R16G16B16_USCALED = VK_FORMAT_R16G16B16_USCALED, - VULKAN_FORMAT_R16G16B16_SSCALED = VK_FORMAT_R16G16B16_SSCALED, - VULKAN_FORMAT_R16G16B16_UINT = VK_FORMAT_R16G16B16_UINT, - VULKAN_FORMAT_R16G16B16_SINT = VK_FORMAT_R16G16B16_SINT, - VULKAN_FORMAT_R16G16B16_SFLOAT = VK_FORMAT_R16G16B16_SFLOAT, - VULKAN_FORMAT_R16G16B16A16_UNORM = VK_FORMAT_R16G16B16A16_UNORM, - VULKAN_FORMAT_R16G16B16A16_SNORM = VK_FORMAT_R16G16B16A16_SNORM, - VULKAN_FORMAT_R16G16B16A16_USCALED = VK_FORMAT_R16G16B16A16_USCALED, - VULKAN_FORMAT_R16G16B16A16_SSCALED = VK_FORMAT_R16G16B16A16_SSCALED, - VULKAN_FORMAT_R16G16B16A16_UINT = VK_FORMAT_R16G16B16A16_UINT, - VULKAN_FORMAT_R16G16B16A16_SINT = VK_FORMAT_R16G16B16A16_SINT, - VULKAN_FORMAT_R16G16B16A16_SFLOAT = VK_FORMAT_R16G16B16A16_SFLOAT, - VULKAN_FORMAT_R32_UINT = VK_FORMAT_R32_UINT, - VULKAN_FORMAT_R32_SINT = VK_FORMAT_R32_SINT, - VULKAN_FORMAT_R32_SFLOAT = VK_FORMAT_R32_SFLOAT, - VULKAN_FORMAT_R32G32_UINT = VK_FORMAT_R32G32_UINT, - VULKAN_FORMAT_R32G32_SINT = VK_FORMAT_R32G32_SINT, - VULKAN_FORMAT_R32G32_SFLOAT = VK_FORMAT_R32G32_SFLOAT, - VULKAN_FORMAT_R32G32B32_UINT = VK_FORMAT_R32G32B32_UINT, - VULKAN_FORMAT_R32G32B32_SINT = VK_FORMAT_R32G32B32_SINT, - VULKAN_FORMAT_R32G32B32_SFLOAT = VK_FORMAT_R32G32B32_SFLOAT, - VULKAN_FORMAT_R32G32B32A32_UINT = VK_FORMAT_R32G32B32A32_UINT, - VULKAN_FORMAT_R32G32B32A32_SINT = VK_FORMAT_R32G32B32A32_SINT, - VULKAN_FORMAT_R32G32B32A32_SFLOAT = VK_FORMAT_R32G32B32A32_SFLOAT, - VULKAN_FORMAT_R64_UINT = VK_FORMAT_R64_UINT, - VULKAN_FORMAT_R64_SINT = VK_FORMAT_R64_SINT, - VULKAN_FORMAT_R64_SFLOAT = VK_FORMAT_R64_SFLOAT, - VULKAN_FORMAT_R64G64_UINT = VK_FORMAT_R64G64_UINT, - VULKAN_FORMAT_R64G64_SINT = VK_FORMAT_R64G64_SINT, - VULKAN_FORMAT_R64G64_SFLOAT = VK_FORMAT_R64G64_SFLOAT, - VULKAN_FORMAT_R64G64B64_UINT = VK_FORMAT_R64G64B64_UINT, - VULKAN_FORMAT_R64G64B64_SINT = VK_FORMAT_R64G64B64_SINT, - VULKAN_FORMAT_R64G64B64_SFLOAT = VK_FORMAT_R64G64B64_SFLOAT, - VULKAN_FORMAT_R64G64B64A64_UINT = VK_FORMAT_R64G64B64A64_UINT, - VULKAN_FORMAT_R64G64B64A64_SINT = VK_FORMAT_R64G64B64A64_SINT, - VULKAN_FORMAT_R64G64B64A64_SFLOAT = VK_FORMAT_R64G64B64A64_SFLOAT, - VULKAN_FORMAT_B10G11R11_UFLOAT_PACK32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, - VULKAN_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, - VULKAN_FORMAT_D16_UNORM = VK_FORMAT_D16_UNORM, - VULKAN_FORMAT_X8_D24_UNORM_PACK32 = VK_FORMAT_X8_D24_UNORM_PACK32, - VULKAN_FORMAT_D32_SFLOAT = VK_FORMAT_D32_SFLOAT, - VULKAN_FORMAT_S8_UINT = VK_FORMAT_S8_UINT, - VULKAN_FORMAT_D16_UNORM_S8_UINT = VK_FORMAT_D16_UNORM_S8_UINT, - VULKAN_FORMAT_D24_UNORM_S8_UINT = VK_FORMAT_D24_UNORM_S8_UINT, - VULKAN_FORMAT_D32_SFLOAT_S8_UINT = VK_FORMAT_D32_SFLOAT_S8_UINT, - VULKAN_FORMAT_BC1_RGB_UNORM_BLOCK = VK_FORMAT_BC1_RGB_UNORM_BLOCK, - VULKAN_FORMAT_BC1_RGB_SRGB_BLOCK = VK_FORMAT_BC1_RGB_SRGB_BLOCK, - VULKAN_FORMAT_BC1_RGBA_UNORM_BLOCK = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, - VULKAN_FORMAT_BC1_RGBA_SRGB_BLOCK = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, - VULKAN_FORMAT_BC2_UNORM_BLOCK = VK_FORMAT_BC2_UNORM_BLOCK, - VULKAN_FORMAT_BC2_SRGB_BLOCK = VK_FORMAT_BC2_SRGB_BLOCK, - VULKAN_FORMAT_BC3_UNORM_BLOCK = VK_FORMAT_BC3_UNORM_BLOCK, - VULKAN_FORMAT_BC3_SRGB_BLOCK = VK_FORMAT_BC3_SRGB_BLOCK, - VULKAN_FORMAT_BC4_UNORM_BLOCK = VK_FORMAT_BC4_UNORM_BLOCK, - VULKAN_FORMAT_BC4_SNORM_BLOCK = VK_FORMAT_BC4_SNORM_BLOCK, - VULKAN_FORMAT_BC5_UNORM_BLOCK = VK_FORMAT_BC5_UNORM_BLOCK, - VULKAN_FORMAT_BC5_SNORM_BLOCK = VK_FORMAT_BC5_SNORM_BLOCK, - VULKAN_FORMAT_BC6H_UFLOAT_BLOCK = VK_FORMAT_BC6H_UFLOAT_BLOCK, - VULKAN_FORMAT_BC6H_SFLOAT_BLOCK = VK_FORMAT_BC6H_SFLOAT_BLOCK, - VULKAN_FORMAT_BC7_UNORM_BLOCK = VK_FORMAT_BC7_UNORM_BLOCK, - VULKAN_FORMAT_BC7_SRGB_BLOCK = VK_FORMAT_BC7_SRGB_BLOCK, - VULKAN_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, - VULKAN_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, - VULKAN_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, - VULKAN_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, - VULKAN_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, - VULKAN_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, - VULKAN_FORMAT_EAC_R11_UNORM_BLOCK = VK_FORMAT_EAC_R11_UNORM_BLOCK, - VULKAN_FORMAT_EAC_R11_SNORM_BLOCK = VK_FORMAT_EAC_R11_SNORM_BLOCK, - VULKAN_FORMAT_EAC_R11G11_UNORM_BLOCK = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, - VULKAN_FORMAT_EAC_R11G11_SNORM_BLOCK = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, - VULKAN_FORMAT_ASTC_4x4_UNORM_BLOCK = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_4x4_SRGB_BLOCK = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_5x4_UNORM_BLOCK = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_5x4_SRGB_BLOCK = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_5x5_UNORM_BLOCK = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_5x5_SRGB_BLOCK = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_6x5_UNORM_BLOCK = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_6x5_SRGB_BLOCK = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_6x6_UNORM_BLOCK = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_6x6_SRGB_BLOCK = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_8x5_UNORM_BLOCK = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_8x5_SRGB_BLOCK = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_8x6_UNORM_BLOCK = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_8x6_SRGB_BLOCK = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_8x8_UNORM_BLOCK = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_8x8_SRGB_BLOCK = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_10x5_UNORM_BLOCK = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_10x5_SRGB_BLOCK = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_10x6_UNORM_BLOCK = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_10x6_SRGB_BLOCK = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_10x8_UNORM_BLOCK = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_10x8_SRGB_BLOCK = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_10x10_UNORM_BLOCK = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_10x10_SRGB_BLOCK = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_12x10_UNORM_BLOCK = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_12x10_SRGB_BLOCK = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, - VULKAN_FORMAT_ASTC_12x12_UNORM_BLOCK = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, - VULKAN_FORMAT_ASTC_12x12_SRGB_BLOCK = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, -}; - -enum VulkanImageLayout -{ - VULKAN_IMAGE_LAYOUT_UNDEFINED = VK_IMAGE_LAYOUT_UNDEFINED, - VULKAN_IMAGE_LAYOUT_GENERAL = VK_IMAGE_LAYOUT_GENERAL, - VULKAN_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - VULKAN_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, -}; - -enum VulkanImageUsage -{ - VULKAN_IMAGE_USAGE_TRANSFER_SRC = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - VULKAN_IMAGE_USAGE_TRANSFER_DST = VK_IMAGE_USAGE_TRANSFER_DST_BIT, - VULKAN_IMAGE_USAGE_SAMPLED = VK_IMAGE_USAGE_SAMPLED_BIT, - VULKAN_IMAGE_USAGE_STORAGE = VK_IMAGE_USAGE_STORAGE_BIT, - VULKAN_IMAGE_USAGE_COLOR_ATTACHMENT = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - VULKAN_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT = - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - VULKAN_IMAGE_USAGE_TRANSIENT_ATTACHMENT = - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - VULKAN_IMAGE_USAGE_INPUT_ATTACHMENT = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, - VULKAN_IMAGE_USAGE_TRANSFER_SRC_DST = - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, - VULKAN_IMAGE_USAGE_STORAGE_TRANSFER_SRC_DST = VULKAN_IMAGE_USAGE_STORAGE - | VULKAN_IMAGE_USAGE_TRANSFER_SRC | VULKAN_IMAGE_USAGE_TRANSFER_DST, - VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST = - VK_IMAGE_USAGE_SAMPLED_BIT | VULKAN_IMAGE_USAGE_STORAGE - | VULKAN_IMAGE_USAGE_TRANSFER_SRC | VULKAN_IMAGE_USAGE_TRANSFER_DST -}; - -enum VulkanImageTiling -{ - VULKAN_IMAGE_TILING_OPTIMAL = VK_IMAGE_TILING_OPTIMAL, - VULKAN_IMAGE_TILING_LINEAR = VK_IMAGE_TILING_LINEAR -}; - -enum VulkanImageCreateFlag -{ - VULKAN_IMAGE_CREATE_FLAG_NONE = 0, - VULKAN_IMAGE_CREATE_FLAG_MUTABLE_FORMAT = - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, - VULKAN_IMAGE_CREATE_FLAG_CUBE_COMPATIBLE = - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, - VULKAN_IMAGE_CREATE_FLAG_CUBE_COMPATIBLE_MUTABLE_FORMAT = - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT -}; - -enum VulkanImageViewType -{ - VULKAN_IMAGE_VIEW_TYPE_1D = VK_IMAGE_VIEW_TYPE_1D, - VULKAN_IMAGE_VIEW_TYPE_2D = VK_IMAGE_VIEW_TYPE_2D, - VULKAN_IMAGE_VIEW_TYPE_3D = VK_IMAGE_VIEW_TYPE_3D, - VULKAN_IMAGE_VIEW_TYPE_CUBE = VK_IMAGE_VIEW_TYPE_CUBE, - VULKAN_IMAGE_VIEW_TYPE_1D_ARRAY = VK_IMAGE_VIEW_TYPE_1D_ARRAY, - VULKAN_IMAGE_VIEW_TYPE_2D_ARRAY = VK_IMAGE_VIEW_TYPE_2D_ARRAY, - VULKAN_IMAGE_VIEW_TYPE_CUBE_ARRAY = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, -}; - -#endif // _vulkan_wrapper_types_hpp_ +// +// Copyright (c) 2022 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef _vulkan_wrapper_types_hpp_ +#define _vulkan_wrapper_types_hpp_ + +#include + +#define VULKAN_MIN_BUFFER_OFFSET_COPY_ALIGNMENT 4 +#define VULKAN_REMAINING_MIP_LEVELS VK_REMAINING_MIP_LEVELS +#define VULKAN_REMAINING_ARRAY_LAYERS VK_REMAINING_ARRAY_LAYERS + +class VulkanInstance; +class VulkanPhysicalDevice; +class VulkanMemoryHeap; +class VulkanMemoryType; +class VulkanQueueFamily; +class VulkanDevice; +class VulkanQueue; +class VulkanDescriptorSetLayoutBinding; +class VulkanDescriptorSetLayout; +class VulkanPipelineLayout; +class VulkanShaderModule; +class VulkanPipeline; +class VulkanComputePipeline; +class VulkanDescriptorPool; +class VulkanDescriptorSet; +class VulkanCommandPool; +class VulkanCommandBuffer; +class VulkanBuffer; +class VulkanOffset3D; +class VulkanExtent3D; +class VulkanImage; +class VulkanImage2D; +class VulkanImageView; +class VulkanDeviceMemory; +class VulkanSemaphore; + +class VulkanPhysicalDeviceList; +class VulkanMemoryHeapList; +class VulkanMemoryTypeList; +class VulkanQueueFamilyList; +class VulkanQueueFamilyToQueueCountMap; +class VulkanQueueFamilyToQueueListMap; +class VulkanQueueList; +class VulkanCommandBufferList; +class VulkanDescriptorSetLayoutList; +class VulkanBufferList; +class VulkanImage2DList; +class VulkanImageViewList; +class VulkanDeviceMemoryList; +class VulkanSemaphoreList; + +enum VulkanQueueFlag +{ + VULKAN_QUEUE_FLAG_GRAPHICS = VK_QUEUE_GRAPHICS_BIT, + VULKAN_QUEUE_FLAG_COMPUTE = VK_QUEUE_COMPUTE_BIT, + VULKAN_QUEUE_FLAG_TRANSFER = VK_QUEUE_TRANSFER_BIT, + VULKAN_QUEUE_FLAG_MASK_ALL = VULKAN_QUEUE_FLAG_GRAPHICS + | VULKAN_QUEUE_FLAG_COMPUTE | VULKAN_QUEUE_FLAG_TRANSFER +}; + +enum VulkanDescriptorType +{ + VULKAN_DESCRIPTOR_TYPE_SAMPLER = VK_DESCRIPTOR_TYPE_SAMPLER, + VULKAN_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + VULKAN_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, + VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, + VULKAN_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, + VULKAN_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, + VULKAN_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, + VULKAN_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, + VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, + VULKAN_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, +}; + +enum VulkanShaderStage +{ + VULKAN_SHADER_STAGE_VERTEX = VK_SHADER_STAGE_VERTEX_BIT, + VULKAN_SHADER_STAGE_FRAGMENT = VK_SHADER_STAGE_FRAGMENT_BIT, + VULKAN_SHADER_STAGE_COMPUTE = VK_SHADER_STAGE_COMPUTE_BIT, + VULKAN_SHADER_STAGE_ALL_GRAPHICS = VK_SHADER_STAGE_ALL_GRAPHICS, + VULKAN_SHADER_STAGE_ALL = VK_SHADER_STAGE_ALL +}; + +enum VulkanPipelineBindPoint +{ + VULKAN_PIPELINE_BIND_POINT_GRAPHICS = VK_PIPELINE_BIND_POINT_GRAPHICS, + VULKAN_PIPELINE_BIND_POINT_COMPUTE = VK_PIPELINE_BIND_POINT_COMPUTE +}; + +enum VulkanMemoryTypeProperty +{ + VULKAN_MEMORY_TYPE_PROPERTY_NONE = 0, + VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL = + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_COHERENT = + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED = + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, + VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED_COHERENT = + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_COHERENT = + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT + | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED = + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT + | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, + VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED_COHERENT = + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT + | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_CACHED_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT +}; + +enum VulkanMemoryHeapFlag +{ + VULKAN_MEMORY_HEAP_FLAG_NONE = 0, + VULKAN_MEMORY_HEAP_FLAG_DEVICE_LOCAL = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT +}; + +enum VulkanExternalMemoryHandleType +{ + VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE = 0, + VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + | VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR +}; + +enum VulkanExternalSemaphoreHandleType +{ + VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE = 0, + VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT = + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT = + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR +}; + +enum VulkanBufferUsage +{ + VULKAN_BUFFER_USAGE_TRANSFER_SRC = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VULKAN_BUFFER_USAGE_TRANSFER_DST = VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VULKAN_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER = + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, + VULKAN_BUFFER_USAGE_STORAGE_TEXEL_BUFFER = + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, + VULKAN_BUFFER_USAGE_UNIFORM_BUFFER = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + VULKAN_BUFFER_USAGE_STORAGE_BUFFER = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + VULKAN_BUFFER_USAGE_INDEX_BUFFER = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VULKAN_BUFFER_USAGE_VERTEX_BUFFER = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + VULKAN_BUFFER_USAGE_INDIRECT_BUFFER = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, + VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST = + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT + | VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VULKAN_BUFFER_USAGE_UNIFORM_BUFFER_TRANSFER_SRC_DST = + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT + | VK_BUFFER_USAGE_TRANSFER_DST_BIT, +}; + +enum VulkanSharingMode +{ + VULKAN_SHARING_MODE_EXCLUSIVE = VK_SHARING_MODE_EXCLUSIVE, + VULKAN_SHARING_MODE_CONCURRENT = VK_SHARING_MODE_CONCURRENT +}; + +enum VulkanImageType +{ + VULKAN_IMAGE_TYPE_1D = VK_IMAGE_TYPE_1D, + VULKAN_IMAGE_TYPE_2D = VK_IMAGE_TYPE_2D, + VULKAN_IMAGE_TYPE_3D = VK_IMAGE_TYPE_3D +}; + +enum VulkanFormat +{ + VULKAN_FORMAT_UNDEFINED = VK_FORMAT_UNDEFINED, + VULKAN_FORMAT_R4G4_UNORM_PACK8 = VK_FORMAT_R4G4_UNORM_PACK8, + VULKAN_FORMAT_R4G4B4A4_UNORM_PACK16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, + VULKAN_FORMAT_B4G4R4A4_UNORM_PACK16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, + VULKAN_FORMAT_R5G6B5_UNORM_PACK16 = VK_FORMAT_R5G6B5_UNORM_PACK16, + VULKAN_FORMAT_B5G6R5_UNORM_PACK16 = VK_FORMAT_B5G6R5_UNORM_PACK16, + VULKAN_FORMAT_R5G5B5A1_UNORM_PACK16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, + VULKAN_FORMAT_B5G5R5A1_UNORM_PACK16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, + VULKAN_FORMAT_A1R5G5B5_UNORM_PACK16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, + VULKAN_FORMAT_R8_UNORM = VK_FORMAT_R8_UNORM, + VULKAN_FORMAT_R8_SNORM = VK_FORMAT_R8_SNORM, + VULKAN_FORMAT_R8_USCALED = VK_FORMAT_R8_USCALED, + VULKAN_FORMAT_R8_SSCALED = VK_FORMAT_R8_SSCALED, + VULKAN_FORMAT_R8_UINT = VK_FORMAT_R8_UINT, + VULKAN_FORMAT_R8_SINT = VK_FORMAT_R8_SINT, + VULKAN_FORMAT_R8_SRGB = VK_FORMAT_R8_SRGB, + VULKAN_FORMAT_R8G8_SNORM = VK_FORMAT_R8G8_SNORM, + VULKAN_FORMAT_R8G8_UNORM = VK_FORMAT_R8G8_UNORM, + VULKAN_FORMAT_R8G8_USCALED = VK_FORMAT_R8G8_USCALED, + VULKAN_FORMAT_R8G8_SSCALED = VK_FORMAT_R8G8_SSCALED, + VULKAN_FORMAT_R8G8_UINT = VK_FORMAT_R8G8_UINT, + VULKAN_FORMAT_R8G8_SINT = VK_FORMAT_R8G8_SINT, + VULKAN_FORMAT_R8G8_SRGB = VK_FORMAT_R8G8_SRGB, + VULKAN_FORMAT_R8G8B8_UNORM = VK_FORMAT_R8G8B8_UNORM, + VULKAN_FORMAT_R8G8B8_SNORM = VK_FORMAT_R8G8B8_SNORM, + VULKAN_FORMAT_R8G8B8_USCALED = VK_FORMAT_R8G8B8_USCALED, + VULKAN_FORMAT_R8G8B8_SSCALED = VK_FORMAT_R8G8B8_SSCALED, + VULKAN_FORMAT_R8G8B8_UINT = VK_FORMAT_R8G8B8_UINT, + VULKAN_FORMAT_R8G8B8_SINT = VK_FORMAT_R8G8B8_SINT, + VULKAN_FORMAT_R8G8B8_SRGB = VK_FORMAT_R8G8B8_SRGB, + VULKAN_FORMAT_B8G8R8_UNORM = VK_FORMAT_B8G8R8_UNORM, + VULKAN_FORMAT_B8G8R8_SNORM = VK_FORMAT_B8G8R8_SNORM, + VULKAN_FORMAT_B8G8R8_USCALED = VK_FORMAT_B8G8R8_USCALED, + VULKAN_FORMAT_B8G8R8_SSCALED = VK_FORMAT_B8G8R8_SSCALED, + VULKAN_FORMAT_B8G8R8_UINT = VK_FORMAT_B8G8R8_UINT, + VULKAN_FORMAT_B8G8R8_SINT = VK_FORMAT_B8G8R8_SINT, + VULKAN_FORMAT_B8G8R8_SRGB = VK_FORMAT_B8G8R8_SRGB, + VULKAN_FORMAT_R8G8B8A8_UNORM = VK_FORMAT_R8G8B8A8_UNORM, + VULKAN_FORMAT_R8G8B8A8_SNORM = VK_FORMAT_R8G8B8A8_SNORM, + VULKAN_FORMAT_R8G8B8A8_USCALED = VK_FORMAT_R8G8B8A8_USCALED, + VULKAN_FORMAT_R8G8B8A8_SSCALED = VK_FORMAT_R8G8B8A8_SSCALED, + VULKAN_FORMAT_R8G8B8A8_UINT = VK_FORMAT_R8G8B8A8_UINT, + VULKAN_FORMAT_R8G8B8A8_SINT = VK_FORMAT_R8G8B8A8_SINT, + VULKAN_FORMAT_R8G8B8A8_SRGB = VK_FORMAT_R8G8B8A8_SRGB, + VULKAN_FORMAT_B8G8R8A8_UNORM = VK_FORMAT_B8G8R8A8_UNORM, + VULKAN_FORMAT_B8G8R8A8_SNORM = VK_FORMAT_B8G8R8A8_SNORM, + VULKAN_FORMAT_B8G8R8A8_USCALED = VK_FORMAT_B8G8R8A8_USCALED, + VULKAN_FORMAT_B8G8R8A8_SSCALED = VK_FORMAT_B8G8R8A8_SSCALED, + VULKAN_FORMAT_B8G8R8A8_UINT = VK_FORMAT_B8G8R8A8_UINT, + VULKAN_FORMAT_B8G8R8A8_SINT = VK_FORMAT_B8G8R8A8_SINT, + VULKAN_FORMAT_B8G8R8A8_SRGB = VK_FORMAT_B8G8R8A8_SRGB, + VULKAN_FORMAT_A8B8G8R8_UNORM_PACK32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, + VULKAN_FORMAT_A8B8G8R8_SNORM_PACK32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, + VULKAN_FORMAT_A8B8G8R8_USCALED_PACK32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, + VULKAN_FORMAT_A8B8G8R8_SSCALED_PACK32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + VULKAN_FORMAT_A8B8G8R8_UINT_PACK32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, + VULKAN_FORMAT_A8B8G8R8_SINT_PACK32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, + VULKAN_FORMAT_A8B8G8R8_SRGB_PACK32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, + VULKAN_FORMAT_A2R10G10B10_UNORM_PACK32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, + VULKAN_FORMAT_A2R10G10B10_SNORM_PACK32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, + VULKAN_FORMAT_A2R10G10B10_USCALED_PACK32 = + VK_FORMAT_A2R10G10B10_USCALED_PACK32, + VULKAN_FORMAT_A2R10G10B10_SSCALED_PACK32 = + VK_FORMAT_A2R10G10B10_SSCALED_PACK32, + VULKAN_FORMAT_A2R10G10B10_UINT_PACK32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, + VULKAN_FORMAT_A2R10G10B10_SINT_PACK32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, + VULKAN_FORMAT_A2B10G10R10_UNORM_PACK32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, + VULKAN_FORMAT_A2B10G10R10_SNORM_PACK32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, + VULKAN_FORMAT_A2B10G10R10_USCALED_PACK32 = + VK_FORMAT_A2B10G10R10_USCALED_PACK32, + VULKAN_FORMAT_A2B10G10R10_SSCALED_PACK32 = + VK_FORMAT_A2B10G10R10_SSCALED_PACK32, + VULKAN_FORMAT_A2B10G10R10_UINT_PACK32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, + VULKAN_FORMAT_A2B10G10R10_SINT_PACK32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, + VULKAN_FORMAT_R16_UNORM = VK_FORMAT_R16_UNORM, + VULKAN_FORMAT_R16_SNORM = VK_FORMAT_R16_SNORM, + VULKAN_FORMAT_R16_USCALED = VK_FORMAT_R16_USCALED, + VULKAN_FORMAT_R16_SSCALED = VK_FORMAT_R16_SSCALED, + VULKAN_FORMAT_R16_UINT = VK_FORMAT_R16_UINT, + VULKAN_FORMAT_R16_SINT = VK_FORMAT_R16_SINT, + VULKAN_FORMAT_R16_SFLOAT = VK_FORMAT_R16_SFLOAT, + VULKAN_FORMAT_R16G16_UNORM = VK_FORMAT_R16G16_UNORM, + VULKAN_FORMAT_R16G16_SNORM = VK_FORMAT_R16G16_SNORM, + VULKAN_FORMAT_R16G16_USCALED = VK_FORMAT_R16G16_USCALED, + VULKAN_FORMAT_R16G16_SSCALED = VK_FORMAT_R16G16_SSCALED, + VULKAN_FORMAT_R16G16_UINT = VK_FORMAT_R16G16_UINT, + VULKAN_FORMAT_R16G16_SINT = VK_FORMAT_R16G16_SINT, + VULKAN_FORMAT_R16G16_SFLOAT = VK_FORMAT_R16G16_SFLOAT, + VULKAN_FORMAT_R16G16B16_UNORM = VK_FORMAT_R16G16B16_UNORM, + VULKAN_FORMAT_R16G16B16_SNORM = VK_FORMAT_R16G16B16_SNORM, + VULKAN_FORMAT_R16G16B16_USCALED = VK_FORMAT_R16G16B16_USCALED, + VULKAN_FORMAT_R16G16B16_SSCALED = VK_FORMAT_R16G16B16_SSCALED, + VULKAN_FORMAT_R16G16B16_UINT = VK_FORMAT_R16G16B16_UINT, + VULKAN_FORMAT_R16G16B16_SINT = VK_FORMAT_R16G16B16_SINT, + VULKAN_FORMAT_R16G16B16_SFLOAT = VK_FORMAT_R16G16B16_SFLOAT, + VULKAN_FORMAT_R16G16B16A16_UNORM = VK_FORMAT_R16G16B16A16_UNORM, + VULKAN_FORMAT_R16G16B16A16_SNORM = VK_FORMAT_R16G16B16A16_SNORM, + VULKAN_FORMAT_R16G16B16A16_USCALED = VK_FORMAT_R16G16B16A16_USCALED, + VULKAN_FORMAT_R16G16B16A16_SSCALED = VK_FORMAT_R16G16B16A16_SSCALED, + VULKAN_FORMAT_R16G16B16A16_UINT = VK_FORMAT_R16G16B16A16_UINT, + VULKAN_FORMAT_R16G16B16A16_SINT = VK_FORMAT_R16G16B16A16_SINT, + VULKAN_FORMAT_R16G16B16A16_SFLOAT = VK_FORMAT_R16G16B16A16_SFLOAT, + VULKAN_FORMAT_R32_UINT = VK_FORMAT_R32_UINT, + VULKAN_FORMAT_R32_SINT = VK_FORMAT_R32_SINT, + VULKAN_FORMAT_R32_SFLOAT = VK_FORMAT_R32_SFLOAT, + VULKAN_FORMAT_R32G32_UINT = VK_FORMAT_R32G32_UINT, + VULKAN_FORMAT_R32G32_SINT = VK_FORMAT_R32G32_SINT, + VULKAN_FORMAT_R32G32_SFLOAT = VK_FORMAT_R32G32_SFLOAT, + VULKAN_FORMAT_R32G32B32_UINT = VK_FORMAT_R32G32B32_UINT, + VULKAN_FORMAT_R32G32B32_SINT = VK_FORMAT_R32G32B32_SINT, + VULKAN_FORMAT_R32G32B32_SFLOAT = VK_FORMAT_R32G32B32_SFLOAT, + VULKAN_FORMAT_R32G32B32A32_UINT = VK_FORMAT_R32G32B32A32_UINT, + VULKAN_FORMAT_R32G32B32A32_SINT = VK_FORMAT_R32G32B32A32_SINT, + VULKAN_FORMAT_R32G32B32A32_SFLOAT = VK_FORMAT_R32G32B32A32_SFLOAT, + VULKAN_FORMAT_R64_UINT = VK_FORMAT_R64_UINT, + VULKAN_FORMAT_R64_SINT = VK_FORMAT_R64_SINT, + VULKAN_FORMAT_R64_SFLOAT = VK_FORMAT_R64_SFLOAT, + VULKAN_FORMAT_R64G64_UINT = VK_FORMAT_R64G64_UINT, + VULKAN_FORMAT_R64G64_SINT = VK_FORMAT_R64G64_SINT, + VULKAN_FORMAT_R64G64_SFLOAT = VK_FORMAT_R64G64_SFLOAT, + VULKAN_FORMAT_R64G64B64_UINT = VK_FORMAT_R64G64B64_UINT, + VULKAN_FORMAT_R64G64B64_SINT = VK_FORMAT_R64G64B64_SINT, + VULKAN_FORMAT_R64G64B64_SFLOAT = VK_FORMAT_R64G64B64_SFLOAT, + VULKAN_FORMAT_R64G64B64A64_UINT = VK_FORMAT_R64G64B64A64_UINT, + VULKAN_FORMAT_R64G64B64A64_SINT = VK_FORMAT_R64G64B64A64_SINT, + VULKAN_FORMAT_R64G64B64A64_SFLOAT = VK_FORMAT_R64G64B64A64_SFLOAT, + VULKAN_FORMAT_B10G11R11_UFLOAT_PACK32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, + VULKAN_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + VULKAN_FORMAT_D16_UNORM = VK_FORMAT_D16_UNORM, + VULKAN_FORMAT_X8_D24_UNORM_PACK32 = VK_FORMAT_X8_D24_UNORM_PACK32, + VULKAN_FORMAT_D32_SFLOAT = VK_FORMAT_D32_SFLOAT, + VULKAN_FORMAT_S8_UINT = VK_FORMAT_S8_UINT, + VULKAN_FORMAT_D16_UNORM_S8_UINT = VK_FORMAT_D16_UNORM_S8_UINT, + VULKAN_FORMAT_D24_UNORM_S8_UINT = VK_FORMAT_D24_UNORM_S8_UINT, + VULKAN_FORMAT_D32_SFLOAT_S8_UINT = VK_FORMAT_D32_SFLOAT_S8_UINT, + VULKAN_FORMAT_BC1_RGB_UNORM_BLOCK = VK_FORMAT_BC1_RGB_UNORM_BLOCK, + VULKAN_FORMAT_BC1_RGB_SRGB_BLOCK = VK_FORMAT_BC1_RGB_SRGB_BLOCK, + VULKAN_FORMAT_BC1_RGBA_UNORM_BLOCK = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + VULKAN_FORMAT_BC1_RGBA_SRGB_BLOCK = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + VULKAN_FORMAT_BC2_UNORM_BLOCK = VK_FORMAT_BC2_UNORM_BLOCK, + VULKAN_FORMAT_BC2_SRGB_BLOCK = VK_FORMAT_BC2_SRGB_BLOCK, + VULKAN_FORMAT_BC3_UNORM_BLOCK = VK_FORMAT_BC3_UNORM_BLOCK, + VULKAN_FORMAT_BC3_SRGB_BLOCK = VK_FORMAT_BC3_SRGB_BLOCK, + VULKAN_FORMAT_BC4_UNORM_BLOCK = VK_FORMAT_BC4_UNORM_BLOCK, + VULKAN_FORMAT_BC4_SNORM_BLOCK = VK_FORMAT_BC4_SNORM_BLOCK, + VULKAN_FORMAT_BC5_UNORM_BLOCK = VK_FORMAT_BC5_UNORM_BLOCK, + VULKAN_FORMAT_BC5_SNORM_BLOCK = VK_FORMAT_BC5_SNORM_BLOCK, + VULKAN_FORMAT_BC6H_UFLOAT_BLOCK = VK_FORMAT_BC6H_UFLOAT_BLOCK, + VULKAN_FORMAT_BC6H_SFLOAT_BLOCK = VK_FORMAT_BC6H_SFLOAT_BLOCK, + VULKAN_FORMAT_BC7_UNORM_BLOCK = VK_FORMAT_BC7_UNORM_BLOCK, + VULKAN_FORMAT_BC7_SRGB_BLOCK = VK_FORMAT_BC7_SRGB_BLOCK, + VULKAN_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + VULKAN_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + VULKAN_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + VULKAN_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + VULKAN_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + VULKAN_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + VULKAN_FORMAT_EAC_R11_UNORM_BLOCK = VK_FORMAT_EAC_R11_UNORM_BLOCK, + VULKAN_FORMAT_EAC_R11_SNORM_BLOCK = VK_FORMAT_EAC_R11_SNORM_BLOCK, + VULKAN_FORMAT_EAC_R11G11_UNORM_BLOCK = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + VULKAN_FORMAT_EAC_R11G11_SNORM_BLOCK = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + VULKAN_FORMAT_ASTC_4x4_UNORM_BLOCK = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_4x4_SRGB_BLOCK = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_5x4_UNORM_BLOCK = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_5x4_SRGB_BLOCK = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_5x5_UNORM_BLOCK = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_5x5_SRGB_BLOCK = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_6x5_UNORM_BLOCK = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_6x5_SRGB_BLOCK = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_6x6_UNORM_BLOCK = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_6x6_SRGB_BLOCK = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_8x5_UNORM_BLOCK = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_8x5_SRGB_BLOCK = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_8x6_UNORM_BLOCK = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_8x6_SRGB_BLOCK = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_8x8_UNORM_BLOCK = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_8x8_SRGB_BLOCK = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_10x5_UNORM_BLOCK = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_10x5_SRGB_BLOCK = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_10x6_UNORM_BLOCK = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_10x6_SRGB_BLOCK = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_10x8_UNORM_BLOCK = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_10x8_SRGB_BLOCK = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_10x10_UNORM_BLOCK = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_10x10_SRGB_BLOCK = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_12x10_UNORM_BLOCK = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_12x10_SRGB_BLOCK = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + VULKAN_FORMAT_ASTC_12x12_UNORM_BLOCK = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + VULKAN_FORMAT_ASTC_12x12_SRGB_BLOCK = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, +}; + +enum VulkanImageLayout +{ + VULKAN_IMAGE_LAYOUT_UNDEFINED = VK_IMAGE_LAYOUT_UNDEFINED, + VULKAN_IMAGE_LAYOUT_GENERAL = VK_IMAGE_LAYOUT_GENERAL, + VULKAN_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VULKAN_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, +}; + +enum VulkanImageUsage +{ + VULKAN_IMAGE_USAGE_TRANSFER_SRC = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + VULKAN_IMAGE_USAGE_TRANSFER_DST = VK_IMAGE_USAGE_TRANSFER_DST_BIT, + VULKAN_IMAGE_USAGE_SAMPLED = VK_IMAGE_USAGE_SAMPLED_BIT, + VULKAN_IMAGE_USAGE_STORAGE = VK_IMAGE_USAGE_STORAGE_BIT, + VULKAN_IMAGE_USAGE_COLOR_ATTACHMENT = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + VULKAN_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT = + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + VULKAN_IMAGE_USAGE_TRANSIENT_ATTACHMENT = + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + VULKAN_IMAGE_USAGE_INPUT_ATTACHMENT = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, + VULKAN_IMAGE_USAGE_TRANSFER_SRC_DST = + VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, + VULKAN_IMAGE_USAGE_STORAGE_TRANSFER_SRC_DST = VULKAN_IMAGE_USAGE_STORAGE + | VULKAN_IMAGE_USAGE_TRANSFER_SRC | VULKAN_IMAGE_USAGE_TRANSFER_DST, + VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST = + VK_IMAGE_USAGE_SAMPLED_BIT | VULKAN_IMAGE_USAGE_STORAGE + | VULKAN_IMAGE_USAGE_TRANSFER_SRC | VULKAN_IMAGE_USAGE_TRANSFER_DST +}; + +enum VulkanImageTiling +{ + VULKAN_IMAGE_TILING_OPTIMAL = VK_IMAGE_TILING_OPTIMAL, + VULKAN_IMAGE_TILING_LINEAR = VK_IMAGE_TILING_LINEAR +}; + +enum VulkanImageCreateFlag +{ + VULKAN_IMAGE_CREATE_FLAG_NONE = 0, + VULKAN_IMAGE_CREATE_FLAG_MUTABLE_FORMAT = + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, + VULKAN_IMAGE_CREATE_FLAG_CUBE_COMPATIBLE = + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, + VULKAN_IMAGE_CREATE_FLAG_CUBE_COMPATIBLE_MUTABLE_FORMAT = + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT +}; + +enum VulkanImageViewType +{ + VULKAN_IMAGE_VIEW_TYPE_1D = VK_IMAGE_VIEW_TYPE_1D, + VULKAN_IMAGE_VIEW_TYPE_2D = VK_IMAGE_VIEW_TYPE_2D, + VULKAN_IMAGE_VIEW_TYPE_3D = VK_IMAGE_VIEW_TYPE_3D, + VULKAN_IMAGE_VIEW_TYPE_CUBE = VK_IMAGE_VIEW_TYPE_CUBE, + VULKAN_IMAGE_VIEW_TYPE_1D_ARRAY = VK_IMAGE_VIEW_TYPE_1D_ARRAY, + VULKAN_IMAGE_VIEW_TYPE_2D_ARRAY = VK_IMAGE_VIEW_TYPE_2D_ARRAY, + VULKAN_IMAGE_VIEW_TYPE_CUBE_ARRAY = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, +}; + +#endif // _vulkan_wrapper_types_hpp_ diff --git a/test_conformance/extensions/CMakeLists.txt b/test_conformance/extensions/CMakeLists.txt index 32e2d11e..3187174f 100644 --- a/test_conformance/extensions/CMakeLists.txt +++ b/test_conformance/extensions/CMakeLists.txt @@ -2,3 +2,6 @@ add_subdirectory( cl_ext_cxx_for_opencl ) add_subdirectory( cl_khr_command_buffer ) add_subdirectory( cl_khr_dx9_media_sharing ) add_subdirectory( cl_khr_semaphore ) +if(VULKAN_IS_SUPPORTED) + add_subdirectory( cl_khr_external_semaphore ) +endif() diff --git a/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt b/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt new file mode 100644 index 00000000..6e02ba97 --- /dev/null +++ b/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt @@ -0,0 +1,28 @@ +set(MODULE_NAME CL_KHR_EXTERNAL_SEMAPHORE) + +set(${MODULE_NAME}_SOURCES + main.cpp + test_external_semaphore.cpp +) + +set (CLConform_VULKAN_LIBRARIES_DIR "${VULKAN_LIB_DIR}") + +link_directories(${CLConform_VULKAN_LIBRARIES_DIR}) + +list(APPEND CLConform_INCLUDE_DIR ${VULKAN_INCLUDE_DIR}) + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + +include_directories (${CLConform_INCLUDE_DIR}) + +# needed by Vulkan wrapper to link +if(WIN32) + list(APPEND CLConform_LIBRARIES vulkan-1 vulkan_wrapper) +else(WIN32) + list(APPEND CLConform_LIBRARIES vulkan dl vulkan_wrapper) +endif(WIN32) +set(CMAKE_CXX_FLAGS "-fpermissive") + +include_directories("../../common/vulkan_wrapper") + +include(../../CMakeCommon.txt) diff --git a/test_conformance/extensions/cl_khr_external_semaphore/main.cpp b/test_conformance/extensions/cl_khr_external_semaphore/main.cpp new file mode 100644 index 00000000..193714fc --- /dev/null +++ b/test_conformance/extensions/cl_khr_external_semaphore/main.cpp @@ -0,0 +1,46 @@ +// Copyright (c) 2022 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#include "procs.h" +#include "harness/testHarness.h" + +test_definition test_list[] = { + ADD_TEST(external_semaphores_queries), + ADD_TEST(external_semaphores_multi_context), + ADD_TEST(external_semaphores_simple_1), + // ADD_TEST(external_semaphores_simple_2), + ADD_TEST(external_semaphores_reuse), + ADD_TEST(external_semaphores_cross_queues_ooo), + ADD_TEST(external_semaphores_cross_queues_io), + ADD_TEST(external_semaphores_cross_queues_io2), + ADD_TEST(external_semaphores_multi_signal), + ADD_TEST(external_semaphores_multi_wait), + // ADD_TEST(external_semaphores_order_1), + // ADD_TEST(external_semaphores_order_2), + // ADD_TEST(external_semaphores_order_3), + // ADD_TEST(external_semaphores_invalid_command) +}; + + +int main(int argc, const char *argv[]) +{ + // A device may report the required properties of a queue that + // is compatible with command-buffers via the query + // CL_DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR. We account + // for this in the tests themselves, rather than here, where we have a + // device to query. + const cl_command_queue_properties queue_properties = 0; + return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list, + false, queue_properties, nullptr); +} diff --git a/test_conformance/extensions/cl_khr_external_semaphore/procs.h b/test_conformance/extensions/cl_khr_external_semaphore/procs.h new file mode 100644 index 00000000..753c8fe2 --- /dev/null +++ b/test_conformance/extensions/cl_khr_external_semaphore/procs.h @@ -0,0 +1,82 @@ +// +// Copyright (c) 2022 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef _CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H +#define _CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H + +#include + +// Basic command-buffer tests + +extern int test_external_semaphores_queries(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements); +extern int test_external_semaphores_multi_context(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements); +extern int test_external_semaphores_simple_1(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_simple_2(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_reuse(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_cross_queues_ooo(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_cross_queues_io(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_cross_queues_io2( + cl_device_id deviceID, cl_context context, cl_command_queue defaultQueue, + int num_elements); +extern int test_external_semaphores_multi_signal(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_multi_wait(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_order_1(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_order_2(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_order_3(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_import_export_fd(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_external_semaphores_invalid_command(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +#endif /* CL_KHR_EXTERNAL_SEMAPHORE */ diff --git a/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp b/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp new file mode 100644 index 00000000..a7ed307e --- /dev/null +++ b/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp @@ -0,0 +1,1350 @@ +#include "harness/typeWrappers.h" +#include "harness/extensionHelpers.h" +#include "harness/errorHelpers.h" +#include "opencl_vulkan_wrapper.hpp" +#include +#include + +#define FLUSH_DELAY_S 5 + +#define SEMAPHORE_PARAM_TEST(param_name, param_type, expected) \ + do \ + { \ + param_type value; \ + size_t size; \ + cl_int error = clGetSemaphoreInfoKHR(sema, param_name, sizeof(value), \ + &value, &size); \ + test_error(error, "Unable to get " #param_name " from semaphore"); \ + if (value != expected) \ + { \ + test_fail("ERROR: Parameter %s did not validate! (expected %d, " \ + "got %d)\n", \ + #param_name, expected, value); \ + } \ + if (size != sizeof(value)) \ + { \ + test_fail( \ + "ERROR: Returned size of parameter %s does not validate! " \ + "(expected %d, got %d)\n", \ + #param_name, (int)sizeof(value), (int)size); \ + } \ + } while (false) + +#define SEMAPHORE_PARAM_TEST_ARRAY(param_name, param_type, num_params, \ + expected) \ + do \ + { \ + param_type value[num_params]; \ + size_t size; \ + cl_int error = clGetSemaphoreInfoKHR(sema, param_name, sizeof(value), \ + &value, &size); \ + test_error(error, "Unable to get " #param_name " from semaphore"); \ + if (size != sizeof(value)) \ + { \ + test_fail( \ + "ERROR: Returned size of parameter %s does not validate! " \ + "(expected %d, got %d)\n", \ + #param_name, (int)sizeof(value), (int)size); \ + } \ + if (memcmp(value, expected, size) != 0) \ + { \ + test_fail("ERROR: Parameter %s did not validate!\n", #param_name); \ + } \ + } while (false) + +static const char* source = "__kernel void empty() {}"; + +static int init_vuikan_device() +{ + cl_platform_id platform = nullptr; + + cl_int err = CL_SUCCESS; + + err = clGetPlatformIDs(1, &platform, NULL); + if (err != CL_SUCCESS) + { + print_error(err, "Error: Failed to get platform\n"); + return err; + } + + init_cl_vk_ext(platform); + + return CL_SUCCESS; +} + +// Confirm the semaphores can be successfully queried +int test_external_semaphores_queries(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + GET_PFN(deviceID, clGetSemaphoreInfoKHR); + GET_PFN(deviceID, clReleaseSemaphoreKHR); + GET_PFN(deviceID, clRetainSemaphoreKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + // Needed by the macro + cl_semaphore_khr sema = sema_ext.getCLSemaphore(); + + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_TYPE_KHR, cl_semaphore_type_khr, + CL_SEMAPHORE_TYPE_BINARY_KHR); + + SEMAPHORE_PARAM_TEST(CL_DEVICE_HANDLE_LIST_KHR, cl_uint, 1); + + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, cl_uint, 1); + + // Confirm that querying CL_SEMAPHORE_CONTEXT_KHR returns the right context + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_CONTEXT_KHR, cl_context, context); + + // Confirm that querying CL_SEMAPHORE_REFERENCE_COUNT_KHR returns the right + // value + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_REFERENCE_COUNT_KHR, cl_uint, 1); + + cl_int err = CL_SUCCESS; + + err = clRetainSemaphoreKHR(sema); + test_error(err, "Could not retain semaphore"); + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_REFERENCE_COUNT_KHR, cl_uint, 2); + + err = clReleaseSemaphoreKHR(sema); + test_error(err, "Could not release semaphore"); + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_REFERENCE_COUNT_KHR, cl_uint, 1); + + // Confirm that querying CL_SEMAPHORE_PAYLOAD_KHR returns the unsignaled + // state + SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_PAYLOAD_KHR, cl_semaphore_payload_khr, 0); + + return TEST_PASS; +} + +int test_external_semaphores_multi_context(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + cl_int err = CL_SUCCESS; + + cl_context context2 = + clCreateContext(NULL, 1, &deviceID, notify_callback, NULL, &err); + if (!context2) + { + print_error(err, "Unable to create testing context"); + return TEST_FAIL; + } + + clExternalSemaphore sema_ext_1(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + clExternalSemaphore sema_ext_2(vkVk2CLSemaphore, context2, + vkExternalSemaphoreHandleType, deviceID); + + clCommandQueueWrapper queue1 = + clCreateCommandQueue(context, deviceID, 0, &err); + test_error(err, "Could not create command queue"); + + clCommandQueueWrapper queue2 = + clCreateCommandQueue(context2, deviceID, 0, &err); + test_error(err, "Could not create command queue"); + + // Signal semaphore 1 and 2 + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore 1 + clEventWrapper wait_1_event; + err = clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &wait_1_event); + test_error(err, "Could not wait semaphore"); + + err = clEnqueueSignalSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore 2 + clEventWrapper wait_2_event; + err = clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &wait_2_event); + test_error(err, "Could not wait semaphore"); + + // Finish + err = clFinish(queue1); + test_error(err, "Could not finish queue"); + + err = clFinish(queue2); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_1_event); + test_assert_event_complete(wait_2_event); + + return TEST_PASS; +} + +// Helper function that signals and waits on semaphore across two different +// queues. +static int semaphore_external_cross_queue_helper(cl_device_id deviceID, + cl_context context, + cl_command_queue queue_1, + cl_command_queue queue_2) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + cl_int err = CL_SUCCESS; + + // Signal semaphore on queue_1 + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue_1, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore on queue_2 + clEventWrapper wait_event; + err = clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Finish queue_1 and queue_2 + err = clFinish(queue_1); + test_error(err, "Could not finish queue"); + + err = clFinish(queue_2); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + +// Confirm that a signal followed by a wait will complete successfully +int test_external_semaphores_simple_1(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Signal semaphore + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore + clEventWrapper wait_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + +// Confirm that signal a semaphore with no event dependencies will not result +// in an implicit dependency on everything previously submitted +int test_external_semaphores_simple_2(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Create user event + clEventWrapper user_event = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + // Create Kernel + clProgramWrapper program; + clKernelWrapper kernel; + err = create_single_kernel_helper(context, &program, &kernel, 1, &source, + "empty"); + test_error(err, "Could not create kernel"); + + // Enqueue task_1 (dependency on user_event) + clEventWrapper task_1_event; + err = clEnqueueTask(queue, kernel, 1, &user_event, &task_1_event); + test_error(err, "Could not enqueue task 1"); + + // Signal semaphore + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore + clEventWrapper wait_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Flush and delay + err = clFlush(queue); + test_error(err, "Could not flush queue"); + std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S)); + + // Ensure all events are completed except for task_1 + test_assert_event_inprogress(task_1_event); + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_event); + + // Complete user_event + err = clSetUserEventStatus(user_event, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(task_1_event); + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + +// Confirm that a semaphore can be reused multiple times +int test_external_semaphores_reuse(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Create Kernel + clProgramWrapper program; + clKernelWrapper kernel; + err = create_single_kernel_helper(context, &program, &kernel, 1, &source, + "empty"); + test_error(err, "Could not create kernel"); + + constexpr size_t loop_count = 10; + clEventWrapper signal_events[loop_count]; + clEventWrapper wait_events[loop_count]; + clEventWrapper task_events[loop_count]; + + // Enqueue task_1 + err = clEnqueueTask(queue, kernel, 0, nullptr, &task_events[0]); + test_error(err, "Unable to enqueue task_1"); + + // Signal semaphore (dependency on task_1) + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &task_events[0], + &signal_events[0]); + test_error(err, "Could not signal semaphore"); + + // In a loop + size_t loop; + for (loop = 1; loop < loop_count; ++loop) + { + // Wait semaphore + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, + &wait_events[loop - 1]); + test_error(err, "Could not wait semaphore"); + + // Enqueue task_loop (dependency on wait) + err = clEnqueueTask(queue, kernel, 1, &wait_events[loop - 1], + &task_events[loop]); + test_error(err, "Unable to enqueue task_loop"); + + // Wait for the "wait semaphore" to complete + err = clWaitForEvents(1, &wait_events[loop - 1]); + test_error(err, "Unable to wait for wait semaphore to complete"); + + // Signal semaphore (dependency on task_loop) + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &task_events[loop], + &signal_events[loop]); + test_error(err, "Could not signal semaphore"); + } + + // Wait semaphore + err = + clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &wait_events[loop - 1]); + test_error(err, "Could not wait semaphore"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + for (loop = 0; loop < loop_count; ++loop) + { + test_assert_event_complete(wait_events[loop]); + test_assert_event_complete(signal_events[loop]); + test_assert_event_complete(task_events[loop]); + } + + return TEST_PASS; +} + +// Helper function that signals and waits on semaphore across two different +// queues. +static int external_semaphore_cross_queue_helper(cl_device_id deviceID, + cl_context context, + cl_command_queue queue_1, + cl_command_queue queue_2) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Signal semaphore on queue_1 + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue_1, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore on queue_2 + clEventWrapper wait_event; + err = clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Finish queue_1 and queue_2 + err = clFinish(queue_1); + test_error(err, "Could not finish queue"); + + err = clFinish(queue_2); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + + +// Confirm that a semaphore works across different ooo queues +int test_external_semaphores_cross_queues_ooo(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + cl_int err; + + // Create ooo queues + clCommandQueueWrapper queue_1 = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + clCommandQueueWrapper queue_2 = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + return external_semaphore_cross_queue_helper(deviceID, context, queue_1, + queue_2); +} + +// Confirm that a semaphore works across different in-order queues +int test_external_semaphores_cross_queues_io(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + cl_int err; + + // Create in-order queues + clCommandQueueWrapper queue_1 = + clCreateCommandQueue(context, deviceID, 0, &err); + test_error(err, "Could not create command queue"); + + clCommandQueueWrapper queue_2 = + clCreateCommandQueue(context, deviceID, 0, &err); + test_error(err, "Could not create command queue"); + + return external_semaphore_cross_queue_helper(deviceID, context, queue_1, + queue_2); +} + +int test_external_semaphores_cross_queues_io2(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + cl_int err = CL_SUCCESS; + + cl_context context2 = + clCreateContext(NULL, 1, &deviceID, notify_callback, NULL, &err); + if (!context2) + { + print_error(err, "Unable to create testing context"); + return TEST_FAIL; + } + + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext_1(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + clExternalSemaphore sema_ext_2(vkVk2CLSemaphore, context2, + vkExternalSemaphoreHandleType, deviceID); + + clCommandQueueWrapper queue1 = + clCreateCommandQueue(context, deviceID, 0, &err); + test_error(err, "Could not create command queue"); + + clCommandQueueWrapper queue2 = + clCreateCommandQueue(context2, deviceID, 0, &err); + test_error(err, "Could not create command queue"); + + // Signal semaphore 1 and 2 + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore 1 + clEventWrapper wait_1_event; + err = clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &wait_1_event); + test_error(err, "Could not wait semaphore"); + + err = clEnqueueSignalSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore 2 + clEventWrapper wait_2_event; + err = clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &wait_2_event); + test_error(err, "Could not wait semaphore"); + + // Finish + err = clFinish(queue1); + test_error(err, "Could not finish queue"); + + err = clFinish(queue2); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_1_event); + test_assert_event_complete(wait_2_event); + + return TEST_PASS; +} + +// Confirm that we can signal multiple semaphores with one command +int test_external_semaphores_multi_signal(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore1(vkDevice, vkExternalSemaphoreHandleType); + VulkanSemaphore vkVk2CLSemaphore2(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext_1(vkVk2CLSemaphore1, context, + vkExternalSemaphoreHandleType, deviceID); + clExternalSemaphore sema_ext_2(vkVk2CLSemaphore2, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Signal semaphore 1 and 2 + clEventWrapper signal_event; + cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(), + sema_ext_2.getCLSemaphore() }; + err = clEnqueueSignalSemaphoresKHR(queue, 2, sema_list, nullptr, 0, nullptr, + &signal_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore 1 + clEventWrapper wait_1_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &wait_1_event); + test_error(err, "Could not wait semaphore"); + + // Wait semaphore 2 + clEventWrapper wait_2_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &wait_2_event); + test_error(err, "Could not wait semaphore"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_1_event); + test_assert_event_complete(wait_2_event); + + return TEST_PASS; +} + +// Confirm that we can wait for multiple semaphores with one command +int test_external_semaphores_multi_wait(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore1(vkDevice, vkExternalSemaphoreHandleType); + VulkanSemaphore vkVk2CLSemaphore2(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext_1(vkVk2CLSemaphore1, context, + vkExternalSemaphoreHandleType, deviceID); + clExternalSemaphore sema_ext_2(vkVk2CLSemaphore2, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Signal semaphore 1 + clEventWrapper signal_1_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &signal_1_event); + test_error(err, "Could not signal semaphore"); + + // Signal semaphore 2 + clEventWrapper signal_2_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &signal_2_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore 1 and 2 + clEventWrapper wait_event; + cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(), + sema_ext_2.getCLSemaphore() }; + err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 0, nullptr, + &wait_event); + test_error(err, "Could not wait semaphore"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_1_event); + test_assert_event_complete(signal_2_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + +// Confirm that it is possible to enqueue a signal of wait and signal in any +// order as soon as the submission order (after deferred dependencies) is +// correct. Case: first one deferred wait, then one non deferred signal. +int test_external_semaphores_order_1(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Create user event + clEventWrapper user_event = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + // Wait semaphore (dependency on user_event) + clEventWrapper wait_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Signal semaphore + clEventWrapper signal_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); + test_error(err, "Could not signal semaphore"); + + // Flush and delay + err = clFlush(queue); + test_error(err, "Could not flush queue"); + std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S)); + + // Ensure signal event is completed while wait event is not + test_assert_event_complete(signal_event); + test_assert_event_inprogress(wait_event); + + // Complete user_event + err = clSetUserEventStatus(user_event, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + +// Confirm that it is possible to enqueue a signal of wait and signal in any +// order as soon as the submission order (after deferred dependencies) is +// correct. Case: first two deferred signals, then one deferred wait. Unblock +// signal, then unblock wait. When wait completes, unblock the other signal. +int test_external_semaphores_order_2(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Create user events + clEventWrapper user_event_1 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + clEventWrapper user_event_2 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + clEventWrapper user_event_3 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + // Signal semaphore (dependency on user_event_1) + clEventWrapper signal_1_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_1, + &signal_1_event); + test_error(err, "Could not signal semaphore"); + + // Signal semaphore (dependency on user_event_2) + clEventWrapper signal_2_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_2, + &signal_2_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore (dependency on user_event_3) + clEventWrapper wait_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_3, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Complete user_event_1 + err = clSetUserEventStatus(user_event_1, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Complete user_event_3 + err = clSetUserEventStatus(user_event_3, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Flush and delay + err = clFlush(queue); + test_error(err, "Could not flush queue"); + std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S)); + + // Ensure all events are completed except for second signal + test_assert_event_complete(signal_1_event); + test_assert_event_inprogress(signal_2_event); + test_assert_event_complete(wait_event); + + // Complete user_event_2 + err = clSetUserEventStatus(user_event_2, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_1_event); + test_assert_event_complete(signal_2_event); + test_assert_event_complete(wait_event); + + return TEST_PASS; +} + +// Confirm that it is possible to enqueue a signal of wait and signal in any +// order as soon as the submission order (after deferred dependencies) is +// correct. Case: first two deferred signals, then two deferred waits. Unblock +// one signal and one wait (both blocked by the same user event). When wait +// completes, unblock the other signal. Then unblock the other wait. +int test_external_semaphores_order_3(cl_device_id deviceID, cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext(vkVk2CLSemaphore, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Create user events + clEventWrapper user_event_1 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + clEventWrapper user_event_2 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + clEventWrapper user_event_3 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + // Signal semaphore (dependency on user_event_1) + clEventWrapper signal_1_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_1, + &signal_1_event); + test_error(err, "Could not signal semaphore"); + + // Signal semaphore (dependency on user_event_2) + clEventWrapper signal_2_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_2, + &signal_2_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore (dependency on user_event_3) + clEventWrapper wait_1_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_3, &wait_1_event); + test_error(err, "Could not wait semaphore"); + + // Wait semaphore (dependency on user_event_2) + clEventWrapper wait_2_event; + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &user_event_2, &wait_2_event); + test_error(err, "Could not wait semaphore"); + + // Complete user_event_2 + err = clSetUserEventStatus(user_event_2, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Flush and delay + err = clFlush(queue); + test_error(err, "Could not flush queue"); + std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S)); + + // Ensure only second signal and second wait completed + cl_event event_list[] = { signal_2_event, wait_2_event }; + err = clWaitForEvents(2, event_list); + test_error(err, "Could not wait for events"); + + test_assert_event_inprogress(signal_1_event); + test_assert_event_inprogress(wait_1_event); + + // Complete user_event_1 + err = clSetUserEventStatus(user_event_1, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Complete user_event_3 + err = clSetUserEventStatus(user_event_3, CL_COMPLETE); + test_error(err, "Could not set user event to CL_COMPLETE"); + + // Finish + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + // Ensure all events are completed + test_assert_event_complete(signal_1_event); + test_assert_event_complete(signal_2_event); + test_assert_event_complete(wait_1_event); + test_assert_event_complete(wait_2_event); + + return TEST_PASS; +} + +// Test that an invalid semaphore command results in the invalidation of the +// command's event and the dependencies' events +int test_external_semaphores_invalid_command(cl_device_id deviceID, + cl_context context, + cl_command_queue defaultQueue, + int num_elements) +{ + if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + { + log_info("cl_khr_semaphore is not supported on this platoform. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + if (init_vuikan_device()) + { + log_info("Cannot initialise Vulkan. " + "Skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + VulkanDevice vkDevice; + + // Obtain pointers to semaphore's API + GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); + GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); + + const std::vector + vkExternalMemoryHandleTypeList = + getSupportedVulkanExternalMemoryHandleTypeList(); + VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType = + getSupportedVulkanExternalSemaphoreHandleTypeList()[0]; + VulkanSemaphore vkVk2CLSemaphore1(vkDevice, vkExternalSemaphoreHandleType); + VulkanSemaphore vkVk2CLSemaphore2(vkDevice, vkExternalSemaphoreHandleType); + + clExternalSemaphore sema_ext_1(vkVk2CLSemaphore1, context, + vkExternalSemaphoreHandleType, deviceID); + clExternalSemaphore sema_ext_2(vkVk2CLSemaphore2, context, + vkExternalSemaphoreHandleType, deviceID); + + cl_int err = CL_SUCCESS; + + // Create ooo queue + clCommandQueueWrapper queue = clCreateCommandQueue( + context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + test_error(err, "Could not create command queue"); + + // Create user events + clEventWrapper user_event_1 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + clEventWrapper user_event_2 = clCreateUserEvent(context, &err); + test_error(err, "Could not create user event"); + + // Signal semaphore_1 (dependency on user_event_1) + clEventWrapper signal_1_event; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 1, &user_event_1, + &signal_1_event); + test_error(err, "Could not signal semaphore"); + + // Wait semaphore_1 and semaphore_2 (dependency on user_event_1) + clEventWrapper wait_event; + cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(), + sema_ext_2.getCLSemaphore() }; + err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 1, + &user_event_1, &wait_event); + test_error(err, "Could not wait semaphore"); + + // Signal semaphore_1 (dependency on wait_event and user_event_2) + clEventWrapper signal_2_event; + cl_event wait_list[] = { user_event_2, wait_event }; + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 2, wait_list, &signal_2_event); + test_error(err, "Could not signal semaphore"); + + // Flush and delay + err = clFlush(queue); + test_error(err, "Could not flush queue"); + std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S)); + + // Ensure all events are not completed + test_assert_event_inprogress(signal_1_event); + test_assert_event_inprogress(signal_2_event); + test_assert_event_inprogress(wait_event); + + // Complete user_event_1 (expect failure as waiting on semaphore_2 is not + // allowed (unsignaled) + err = clSetUserEventStatus(user_event_1, CL_COMPLETE); + test_assert_error(err != CL_SUCCESS, + "signal_2_event completed unexpectedly"); + + // Ensure signal_1 is completed while others failed (the second signal + // should fail as it depends on wait) + err = clFinish(queue); + test_error(err, "Could not finish queue"); + + test_assert_event_complete(signal_1_event); + test_assert_event_terminated(wait_event); + test_assert_event_terminated(signal_2_event); + + return TEST_PASS; +} diff --git a/test_conformance/vulkan/CMakeLists.txt b/test_conformance/vulkan/CMakeLists.txt index 4f43172a..9778693b 100644 --- a/test_conformance/vulkan/CMakeLists.txt +++ b/test_conformance/vulkan/CMakeLists.txt @@ -1,12 +1,12 @@ set (MODULE_NAME VULKAN) if(WIN32) - list(APPEND CLConform_LIBRARIES vulkan-1) + list(APPEND CLConform_LIBRARIES vulkan-1 vulkan_wrapper) else(WIN32) - list(APPEND CLConform_LIBRARIES vulkan dl) + list(APPEND CLConform_LIBRARIES vulkan dl vulkan_wrapper) endif(WIN32) set(CMAKE_CXX_FLAGS "-fpermissive") -if(WIN32) +if(WIN32) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_USE_PLATFORM_WIN32_KHR") endif(WIN32) @@ -26,11 +26,7 @@ set (${MODULE_NAME}_SOURCES test_vulkan_interop_image.cpp test_vulkan_api_consistency.cpp test_vulkan_platform_device_info.cpp - vulkan_interop_common/vulkan_wrapper.cpp - vulkan_interop_common/vulkan_interop_common.cpp - vulkan_interop_common/opencl_vulkan_wrapper.cpp - vulkan_interop_common/vulkan_utility.cpp - vulkan_interop_common/vulkan_list_map.cpp + vulkan_interop_common.cpp ../../test_common/harness/genericThread.cpp ../../test_common/harness/errorHelpers.cpp ../../test_common/harness/testHarness.cpp @@ -45,6 +41,6 @@ set (${MODULE_NAME}_SOURCES set_source_files_properties( ${${MODULE_NAME}_SOURCES} PROPERTIES LANGUAGE CXX) -include_directories("./vulkan_interop_common/") +include_directories("../common/vulkan_wrapper") include(../CMakeCommon.txt) diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_interop_common.cpp b/test_conformance/vulkan/vulkan_interop_common.cpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_interop_common.cpp rename to test_conformance/vulkan/vulkan_interop_common.cpp diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_interop_common.hpp b/test_conformance/vulkan/vulkan_interop_common.hpp similarity index 100% rename from test_conformance/vulkan/vulkan_interop_common/vulkan_interop_common.hpp rename to test_conformance/vulkan/vulkan_interop_common.hpp