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