ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial CTS for external semaphore and memory extensions (#1390)

Browse Source 
* Initial CTS for external sharing extensions

Initial set of tests for below extensions
with Vulkan as producer
1. cl_khr_external_memory
2. cl_khr_external_memory_win32
3. cl_khr_external_memory_opaque_fd
4. cl_khr_external_semaphore
5. cl_khr_external_semaphore_win32
6. cl_khr_external_semaphore_opaque_fd

* Updates to external sharing CTS

Updates to external sharing CTS
1. Fix some build issues to remove unnecessary, non-existent files
2. Add new tests for platform and device queries.
3. Some added checks for VK Support.

* Update CTS build script for Vulkan Headers

Update CTS build to clone Vulkan Headers
repo and pass it to CTS build
in preparation for external memory
and semaphore tests

* Fix Vulkan header path

Fix Vulkan header include path.

* Add Vulkan loader dependency

Vulkan loader is required to build
test_vulkan of OpenCL-CTS.
Clone and build Vulkan loader as prerequisite
to OpenCL-CTS.

* Fix Vulkan loader path in test_vulkan

Remove arch/os suffix in Vulkan loader path
to match vulkan loader repo build.

* Fix warnings around getHandle API.

Return type of getHandle is defined
differently based on win or linux builds.
Use appropriate guards when using API
at other places.
While at it remove duplicate definition
of ARRAY_SIZE.

* Use ARRAY_SIZE in harness.

Use already defined ARRAY_SIZE macro
from test_harness.

* Fix build issues for test_vulkan

Fix build issues for test_vulkan
1. Add cl_ext.h in common files
2. Replace cl_mem_properties_khr with cl_mem_properties
3. Replace cl_external_mem_handle_type_khr with
cl_external_memory_handle_type_khr
4. Type-cast malloc as required.

* Fix code formatting.

Fix code formatting to
get CTS CI builds clean.

* Fix formatting fixes part-2

Another set of formatting fixes.

* Fix code formatting part-3

Some more code formatting fixes.

* Fix code formatting issues part-4

More code formatting fixes.

* Formatting fixes part-5

Some more formatting fixes

* Fix formatting part-6

More formatting fixes continued.

* Code formatting fixes part-7

Code formatting fixes for image

* Code formatting fixes part-8

Fixes for platform and device query tests.

* Code formatting fixes part-9

More formatting fixes for vulkan_wrapper

* Code formatting fixes part-10

More fixes to wrapper header

* Code formatting fixes part-11

Formatting fixes for api_list

* Code formatting fixes part-12

Formatting fixes for api_list_map.

* Code formatting changes part-13

Code formatting changes for utility.

* Code formatting fixes part-15
Formatting fixes for wrapper.

* Misc Code formatting fixes

Some more misc code formatting fixes.

* Fix build breaks due to code formatting

Fix build issues arised with recent
code formatting issues.

* Fix presubmit script after merge

Fix presubmit script after merge conflicts.

* Fix Vulkan loader build in presubmit script.

Use cmake ninja and appropriate toolchain
for Vulkan loader dependency to fix
linking issue on arm/aarch64.

* Use static array sizes

Use static array sizes to fix
windows builds.

* Some left-out formatting fixes.

Fix remaining formatting issues.

* Fix harness header path

Fix harness header path
While at it, remove Misc and test pragma.

* Add/Fix license information

Add Khronos License info for test_vulkan.
Replace Apple license with Khronos
as applicable.

* Fix headers for Mac OSX builds.

Use appropriate headers for
Mac OSX builds

* Fix Mac OSX builds.

Use appropriate headers for
Mac OSX builds.
Also, fix some build issues
due to type-casting.

* Fix new code formatting issues

Fix new code formatting issues
with recent MacOS fixes.

* Add back missing case statement

Add back missing case statement
that was accidentally removed.

* Disable USE_GAS for Vulkan Loader build.

Disable USE_GAS for Vulkan Loader build
to fix aarch64 build.

* Update Copyright Year.

Update Copyright Year to 2022
for external memory sharing tests.

* Android specific fixes

Android specific fixes to
external sharing tests.
This commit is contained in:
Nikhil Joshi
2022-06-21 21:51:47 +05:30
committed by GitHub
parent 67ac6c8d2d
commit 0b7118186a
23 changed files with 10535 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
test_conformance/vulkan/CMakeLists.txt Normal file
View File

@@ -0,0 +1,50 @@
set (MODULE_NAME VULKAN)
if(WIN32)
list(APPEND CLConform_LIBRARIES vulkan-1)
else(WIN32)
list(APPEND CLConform_LIBRARIES vulkan dl)
endif(WIN32)
set(CMAKE_CXX_FLAGS "-fpermissive")
if(WIN32)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_USE_PLATFORM_WIN32_KHR")
endif(WIN32)
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})
set (${MODULE_NAME}_SOURCES
main.cpp
test_vulkan_interop_buffer.cpp
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
../../test_common/harness/genericThread.cpp
../../test_common/harness/errorHelpers.cpp
../../test_common/harness/testHarness.cpp
../../test_common/harness/kernelHelpers.cpp
../../test_common/harness/mt19937.cpp
../../test_common/harness/msvc9.c
../../test_common/harness/parseParameters.cpp
../../test_common/harness/deviceInfo.cpp
../../test_common/harness/crc32.cpp
)
set_source_files_properties(
${${MODULE_NAME}_SOURCES}
PROPERTIES LANGUAGE CXX)
include_directories("./vulkan_interop_common/")
include(../CMakeCommon.txt)

344
test_conformance/vulkan/main.cpp Normal file
View File

@@ -0,0 +1,344 @@
//
// 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 <stdio.h>
#include <stdlib.h>
#if !defined(_WIN32)
#include <stdbool.h>
#endif
#include <math.h>
#include <string.h>
#if !defined(__APPLE__)
#include <CL/cl.h>
#else
#include <OpenCL/cl.h>
#endif
#include "procs.h"
#include "harness/testHarness.h"
#include "harness/parseParameters.h"
#include "harness/deviceInfo.h"
#if !defined(_WIN32)
#include <unistd.h>
#endif
#include <vulkan_interop_common.hpp>
#include <vulkan_wrapper.hpp>
#define BUFFERSIZE 3000
static void params_reset()
{
numCQ = 1;
multiImport = false;
multiCtx = false;
}
extern int test_buffer_common(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_);
extern int test_image_common(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_);
int test_buffer_single_queue(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_)
{
params_reset();
log_info("RUNNING TEST WITH ONE QUEUE...... \n\n");
return test_buffer_common(device_, context_, queue_, numElements_);
}
int test_buffer_multiple_queue(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_)
{
params_reset();
numCQ = 2;
log_info("RUNNING TEST WITH TWO QUEUE...... \n\n");
return test_buffer_common(device_, context_, queue_, numElements_);
}
int test_buffer_multiImport_sameCtx(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_)
{
params_reset();
multiImport = true;
log_info("RUNNING TEST WITH MULTIPLE DEVICE MEMORY IMPORT "
"IN SAME CONTEXT...... \n\n");
return test_buffer_common(device_, context_, queue_, numElements_);
}
int test_buffer_multiImport_diffCtx(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_)
{
params_reset();
multiImport = true;
multiCtx = true;
log_info("RUNNING TEST WITH MULTIPLE DEVICE MEMORY IMPORT "
"IN DIFFERENT CONTEXT...... \n\n");
return test_buffer_common(device_, context_, queue_, numElements_);
}
int test_image_single_queue(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_)
{
params_reset();
log_info("RUNNING TEST WITH ONE QUEUE...... \n\n");
return test_image_common(device_, context_, queue_, numElements_);
}
int test_image_multiple_queue(cl_device_id device_, cl_context context_,
cl_command_queue queue_, int numElements_)
{
params_reset();
numCQ = 2;
log_info("RUNNING TEST WITH TWO QUEUE...... \n\n");
return test_image_common(device_, context_, queue_, numElements_);
}
test_definition test_list[] = { ADD_TEST(buffer_single_queue),
ADD_TEST(buffer_multiple_queue),
ADD_TEST(buffer_multiImport_sameCtx),
ADD_TEST(buffer_multiImport_diffCtx),
ADD_TEST(image_single_queue),
ADD_TEST(image_multiple_queue),
ADD_TEST(consistency_external_buffer),
ADD_TEST(consistency_external_image),
ADD_TEST(consistency_external_semaphore),
ADD_TEST(platform_info),
ADD_TEST(device_info) };
const int test_num = ARRAY_SIZE(test_list);
cl_device_type gDeviceType = CL_DEVICE_TYPE_DEFAULT;
char *choosen_platform_name = NULL;
cl_platform_id platform = NULL;
cl_int choosen_platform_index = -1;
char platform_name[1024] = "";
cl_platform_id select_platform = NULL;
char *extensions = NULL;
size_t extensionSize = 0;
cl_uint num_devices = 0;
cl_uint device_no = 0;
cl_device_id *devices;
const size_t bufsize = BUFFERSIZE;
char buf[BUFFERSIZE];
cl_uchar uuid[CL_UUID_SIZE_KHR];
VulkanDevice vkDevice;
unsigned int numCQ;
bool multiImport;
bool multiCtx;
bool debug_trace = false;
bool useSingleImageKernel = false;
bool useDeviceLocal = false;
bool disableNTHandleType = false;
bool enableOffset = false;
bool non_dedicated = false;
static void printUsage(const char *execName)
{
const char *p = strrchr(execName, '/');
if (p != NULL) execName = p + 1;
log_info("Usage: %s [test_names] [options]\n", execName);
log_info("Test names:\n");
for (int i = 0; i < test_num; i++)
{
log_info("\t%s\n", test_list[i].name);
}
log_info("\n");
log_info("Options:\n");
log_info("\t--debug_trace - Enables additional debug info logging\n");
log_info("\t--non_dedicated - Choose dedicated Vs. non_dedicated \n");
}
size_t parseParams(int argc, const char *argv[], const char **argList)
{
size_t argCount = 1;
for (int i = 1; i < argc; i++)
{
if (argv[i] == NULL) break;
if (argv[i][0] == '-')
{
if (!strcmp(argv[i], "--debug_trace"))
{
debug_trace = true;
}
if (!strcmp(argv[i], "--useSingleImageKernel"))
{
useSingleImageKernel = true;
}
if (!strcmp(argv[i], "--useDeviceLocal"))
{
useDeviceLocal = true;
}
if (!strcmp(argv[i], "--disableNTHandleType"))
{
disableNTHandleType = true;
}
if (!strcmp(argv[i], "--enableOffset"))
{
enableOffset = true;
}
if (!strcmp(argv[i], "--non_dedicated"))
{
non_dedicated = true;
}
if (strcmp(argv[i], "-h") == 0)
{
printUsage(argv[0]);
argCount = 0; // Returning argCount=0 to assert error in main()
break;
}
}
else
{
argList[argCount] = argv[i];
argCount++;
}
}
return argCount;
}
int main(int argc, const char *argv[])
{
int errNum = 0;
test_start();
params_reset();
if (!checkVkSupport())
{
log_info("Vulkan supported GPU not found \n");
return 0;
}
cl_device_type requestedDeviceType = CL_DEVICE_TYPE_GPU;
char *force_cpu = getenv("CL_DEVICE_TYPE");
if (force_cpu != NULL)
{
if (strcmp(force_cpu, "gpu") == 0
|| strcmp(force_cpu, "CL_DEVICE_TYPE_GPU") == 0)
requestedDeviceType = CL_DEVICE_TYPE_GPU;
else if (strcmp(force_cpu, "cpu") == 0
|| strcmp(force_cpu, "CL_DEVICE_TYPE_CPU") == 0)
requestedDeviceType = CL_DEVICE_TYPE_CPU;
else if (strcmp(force_cpu, "accelerator") == 0
|| strcmp(force_cpu, "CL_DEVICE_TYPE_ACCELERATOR") == 0)
requestedDeviceType = CL_DEVICE_TYPE_ACCELERATOR;
else if (strcmp(force_cpu, "CL_DEVICE_TYPE_DEFAULT") == 0)
requestedDeviceType = CL_DEVICE_TYPE_DEFAULT;
}
if (requestedDeviceType != CL_DEVICE_TYPE_GPU)
{
log_info("Vulkan tests can only run on a GPU device.\n");
return 0;
}
gDeviceType = CL_DEVICE_TYPE_GPU;
const char **argList = (const char **)calloc(argc, sizeof(char *));
size_t argCount = parseParams(argc, argv, argList);
if (argCount == 0) return 0;
// get the platform ID
errNum = clGetPlatformIDs(1, &platform, NULL);
if (errNum != CL_SUCCESS)
{
print_error(errNum, "Error: Failed to get platform\n");
return errNum;
}
errNum =
clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &num_devices);
if (CL_SUCCESS != errNum)
{
print_error(errNum, "clGetDeviceIDs failed in returning of devices\n");
return errNum;
}
devices = (cl_device_id *)malloc(num_devices * sizeof(cl_device_id));
if (NULL == devices)
{
print_error(errNum, "Unable to allocate memory for devices\n");
return CL_OUT_OF_HOST_MEMORY;
}
errNum = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, num_devices, devices,
NULL);
if (CL_SUCCESS != errNum)
{
print_error(errNum, "Failed to get deviceID.\n");
return errNum;
}
for (device_no = 0; device_no < num_devices; device_no++)
{
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS, 0,
NULL, &extensionSize);
if (CL_SUCCESS != errNum)
{
log_error("Error in clGetDeviceInfo for getting "
"device_extension size....\n");
return errNum;
}
extensions = (char *)malloc(extensionSize);
if (NULL == extensions)
{
log_error("Unable to allocate memory for extensions\n");
return CL_OUT_OF_HOST_MEMORY;
}
errNum =
clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS,
extensionSize, extensions, NULL /*&extensionSize*/);
if (CL_SUCCESS != errNum)
{
print_error(errNum,
"Error in clGetDeviceInfo for getting "
"device_extension\n");
return errNum;
}
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_UUID_KHR,
CL_UUID_SIZE_KHR, uuid, &extensionSize);
if (CL_SUCCESS != errNum)
{
print_error(errNum, "clGetDeviceInfo failed with error\n ");
return errNum;
}
errNum =
memcmp(uuid, vkDevice.getPhysicalDevice().getUUID(), VK_UUID_SIZE);
if (errNum == 0)
{
break;
}
}
if (device_no >= num_devices)
{
fprintf(stderr,
"OpenCL error: "
"No Vulkan-OpenCL Interop capable GPU found.\n");
}
if (!(is_extension_available(devices[device_no], "cl_khr_external_memory")
&& is_extension_available(devices[device_no],
"cl_khr_external_semaphore")))
{
log_info("Device does not support cl_khr_external_memory "
"or cl_khr_external_semaphore\n");
log_info(" TEST SKIPPED\n");
return CL_SUCCESS;
}
init_cl_vk_ext(platform);
// Execute tests.
// Note: don't use the entire harness, because we have a different way of
// obtaining the device (via the context)
errNum = parseAndCallCommandLineTests(argCount, argList, devices[device_no],
test_num, test_list, true, 0, 1024);
return errNum;
}

38
test_conformance/vulkan/procs.h Normal file
View File

@@ -0,0 +1,38 @@
//
// 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 "harness/mt19937.h"
extern int test_vulkan_interop_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_vulkan_interop_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_consistency_external_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_consistency_external_image(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_consistency_external_semaphore(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_platform_info(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_device_info(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);

568
test_conformance/vulkan/test_vulkan_api_consistency.cpp Normal file
View File

@@ -0,0 +1,568 @@
//
// 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 <vulkan_interop_common.hpp>
#include <opencl_vulkan_wrapper.hpp>
#include <vulkan_wrapper.hpp>
#if !defined(__APPLE__)
#include <CL/cl.h>
#include <CL/cl_ext.h>
#else
#include <OpenCL/cl.h>
#include <OpenCL/cl_ext.h>
#endif
#include <assert.h>
#include <vector>
#include <iostream>
#include <string.h>
#include "harness/testHarness.h"
#include "harness/typeWrappers.h"
#include "harness/deviceInfo.h"
int test_consistency_external_buffer(cl_device_id deviceID, cl_context _context,
cl_command_queue _queue, int num_elements)
{
cl_int errNum;
VulkanDevice vkDevice;
// Context and command queue creation
cl_platform_id platform = NULL;
cl_context context = NULL;
cl_command_queue cmd_queue = NULL;
cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, 0, 0 };
errNum = clGetPlatformIDs(1, &platform, NULL);
test_error(errNum, "Failed to get platform Id");
contextProperties[1] = (cl_context_properties)platform;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
test_error(errNum, "Unable to create context with properties");
cmd_queue = clCreateCommandQueue(context, deviceID, 0, &errNum);
test_error(errNum, "Unable to create command queue");
uint32_t bufferSize = 32;
cl_device_id devList[] = { deviceID, NULL };
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
{
throw std::runtime_error("Device does not support "
"cl_khr_external_memory_win32 extension \n");
}
#else
if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
{
throw std::runtime_error(
"Device does not support "
"cl_khr_external_memory_opaque_fd extension \n");
}
#endif
VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
getSupportedVulkanExternalMemoryHandleTypeList()[0];
VulkanBuffer vkDummyBuffer(vkDevice, 4 * 1024, vkExternalMemoryHandleType);
const VulkanMemoryTypeList& memoryTypeList =
vkDummyBuffer.getMemoryTypeList();
VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
vkDevice, bufferSize, memoryTypeList[0], vkExternalMemoryHandleType);
VulkanBufferList vkBufferList(1, vkDevice, bufferSize,
vkExternalMemoryHandleType);
vkDeviceMem->bindBuffer(vkBufferList[0], 0);
void* handle = NULL;
int fd;
std::vector<cl_mem_properties> extMemProperties{
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR,
(cl_mem_properties)devList[0],
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR,
};
cl_external_memory_handle_type_khr type;
switch (vkExternalMemoryHandleType)
{
#ifdef _WIN32
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR;
errNum = check_external_memory_handle_type(devList[0], type);
extMemProperties.push_back((cl_mem_properties)type);
extMemProperties.push_back((cl_mem_properties)handle);
break;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR;
errNum = check_external_memory_handle_type(devList[0], type);
extMemProperties.push_back((cl_mem_properties)type);
extMemProperties.push_back((cl_mem_properties)handle);
break;
#else
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
fd = (int)vkDeviceMem->getHandle(vkExternalMemoryHandleType);
type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR;
errNum = check_external_memory_handle_type(devList[0], type);
extMemProperties.push_back((cl_mem_properties)type);
extMemProperties.push_back((cl_mem_properties)fd);
break;
#endif
default:
errNum = TEST_FAIL;
log_error("Unsupported external memory handle type \n");
break;
}
if (errNum != CL_SUCCESS)
{
log_error("Checks failed for "
"CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR\n");
return TEST_FAIL;
}
extMemProperties.push_back(0);
clMemWrapper buffer;
// Passing NULL properties and a valid extMem_desc size
buffer = clCreateBufferWithProperties(context, NULL, 1, bufferSize, NULL,
&errNum);
test_error(errNum, "Unable to create buffer with NULL properties");
buffer.reset();
// Passing valid extMemProperties and buffersize
buffer = clCreateBufferWithProperties(context, extMemProperties.data(), 1,
bufferSize, NULL, &errNum);
test_error(errNum, "Unable to create buffer with Properties");
buffer.reset();
// Not passing external memory handle
std::vector<cl_mem_properties> extMemProperties2{
#ifdef _WIN32
(cl_mem_properties)type,
NULL, // Passing NULL handle
#else
(cl_mem_properties)type,
(cl_mem_properties)-64, // Passing random invalid fd
#endif
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR,
(cl_mem_properties)devList[0],
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR,
0
};
buffer = clCreateBufferWithProperties(context, extMemProperties2.data(), 1,
bufferSize, NULL, &errNum);
test_failure_error(errNum, CL_INVALID_VALUE,
"Should return CL_INVALID_VALUE ");
buffer.reset();
// Passing extMem_desc size = 0 but valid memProperties, CL_INVALID_SIZE
// should be returned.
buffer = clCreateBufferWithProperties(context, extMemProperties.data(), 1,
0, NULL, &errNum);
test_failure_error(errNum, CL_INVALID_BUFFER_SIZE,
"Should return CL_INVALID_BUFFER_SIZE");
return TEST_PASS;
}
int test_consistency_external_image(cl_device_id deviceID, cl_context _context,
cl_command_queue _queue, int num_elements)
{
cl_int errNum;
VulkanDevice vkDevice;
// Context and command queue creation
cl_platform_id platform = NULL;
cl_context context = NULL;
cl_command_queue cmd_queue = NULL;
cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, 0, 0 };
errNum = clGetPlatformIDs(1, &platform, NULL);
test_error(errNum, "Failed to get platform id");
contextProperties[1] = (cl_context_properties)platform;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
test_error(errNum, "Unable to create context with properties");
cmd_queue = clCreateCommandQueue(context, deviceID, 0, &errNum);
test_error(errNum, "Unable to create command queue");
cl_device_id devList[] = { deviceID, NULL };
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
{
throw std::runtime_error("Device does not support"
"cl_khr_external_memory_win32 extension \n");
}
#else
if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_memory_opaque_fd "
"extension \n");
}
#endif
uint32_t width = 256;
uint32_t height = 16;
cl_image_desc image_desc;
memset(&image_desc, 0x0, sizeof(cl_image_desc));
cl_image_format img_format = { 0 };
VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
getSupportedVulkanExternalMemoryHandleTypeList()[0];
VulkanImage2D* vkImage2D =
new VulkanImage2D(vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height,
1, vkExternalMemoryHandleType);
const VulkanMemoryTypeList& memoryTypeList = vkImage2D->getMemoryTypeList();
uint64_t totalImageMemSize = vkImage2D->getSize();
log_info("Memory type index: %d\n", (uint32_t)memoryTypeList[0]);
log_info("Memory type property: %d\n",
memoryTypeList[0].getMemoryTypeProperty());
log_info("Image size : %d\n", totalImageMemSize);
VulkanDeviceMemory* vkDeviceMem =
new VulkanDeviceMemory(vkDevice, totalImageMemSize, memoryTypeList[0],
vkExternalMemoryHandleType);
vkDeviceMem->bindImage(*vkImage2D, 0);
void* handle = NULL;
int fd;
std::vector<cl_mem_properties> extMemProperties{
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR,
(cl_mem_properties)devList[0],
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR,
};
switch (vkExternalMemoryHandleType)
{
#ifdef _WIN32
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
errNum = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
extMemProperties.push_back(
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
extMemProperties.push_back((cl_mem_properties)handle);
break;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
errNum = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
extMemProperties.push_back(
(cl_mem_properties)
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
extMemProperties.push_back((cl_mem_properties)handle);
break;
#else
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
fd = (int)vkDeviceMem->getHandle(vkExternalMemoryHandleType);
errNum = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
extMemProperties.push_back(
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
extMemProperties.push_back((cl_mem_properties)fd);
break;
#endif
default:
errNum = TEST_FAIL;
log_error("Unsupported external memory handle type \n");
break;
}
if (errNum != CL_SUCCESS)
{
log_error("Checks failed for "
"CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR\n");
return TEST_FAIL;
}
extMemProperties.push_back(0);
const VkImageCreateInfo VulkanImageCreateInfo =
vkImage2D->getVkImageCreateInfo();
errNum = getCLImageInfoFromVkImageInfo(
&VulkanImageCreateInfo, totalImageMemSize, &img_format, &image_desc);
if (errNum != CL_SUCCESS)
{
log_error("getCLImageInfoFromVkImageInfo failed!!!");
return TEST_FAIL;
}
clMemWrapper image;
// Pass valid properties, image_desc and image_format
image = clCreateImageWithProperties(
context, extMemProperties.data(), CL_MEM_READ_WRITE, &img_format,
&image_desc, NULL /* host_ptr */, &errNum);
test_error(errNum, "Unable to create Image with Properties");
image.reset();
// Passing properties, image_desc and image_format all as NULL
image = clCreateImageWithProperties(context, NULL, CL_MEM_READ_WRITE, NULL,
NULL, NULL, &errNum);
test_failure_error(
errNum, CL_INVALID_IMAGE_DESCRIPTOR,
"Image creation must fail with CL_INVALID_IMAGE_DESCRIPTOR "
"when all are passed as NULL");
image.reset();
// Passing NULL properties and a valid image_format and image_desc
image =
clCreateImageWithProperties(context, NULL, CL_MEM_READ_WRITE,
&img_format, &image_desc, NULL, &errNum);
test_error(errNum,
"Unable to create image with NULL properties "
"with valid image format and image desc");
image.reset();
// Passing image_format as NULL
image = clCreateImageWithProperties(context, extMemProperties.data(),
CL_MEM_READ_WRITE, NULL, &image_desc,
NULL, &errNum);
test_failure_error(errNum, CL_INVALID_IMAGE_FORMAT_DESCRIPTOR,
"Image creation must fail with "
"CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"
"when image desc passed as NULL");
image.reset();
// Passing image_desc as NULL
image = clCreateImageWithProperties(context, extMemProperties.data(),
CL_MEM_READ_WRITE, &img_format, NULL,
NULL, &errNum);
test_failure_error(errNum, CL_INVALID_IMAGE_DESCRIPTOR,
"Image creation must fail with "
"CL_INVALID_IMAGE_DESCRIPTOR "
"when image desc passed as NULL");
image.reset();
return TEST_PASS;
}
int test_consistency_external_semaphore(cl_device_id deviceID,
cl_context _context,
cl_command_queue _queue,
int num_elements)
{
cl_int errNum;
VulkanDevice vkDevice;
// Context and command queue creation
cl_platform_id platform = NULL;
cl_context context = NULL;
cl_command_queue cmd_queue = NULL;
errNum = clGetPlatformIDs(1, &platform, NULL);
test_error(errNum, "Failed to get platform Id");
cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, 0, 0 };
contextProperties[1] = (cl_context_properties)platform;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
test_error(errNum, "Unable to create context with properties");
cmd_queue = clCreateCommandQueue(context, deviceID, 0, &errNum);
test_error(errNum, "Unable to create command queue");
cl_device_id devList[] = { deviceID, NULL };
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_semaphore_win32"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_semaphore_win32 "
"extension \n");
}
#else
if (!is_extension_available(devList[0],
"cl_khr_external_semaphore_opaque_fd"))
{
throw std::runtime_error(
"Device does not support "
"cl_khr_external_semaphore_opaque_fd extension \n");
}
#endif
VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType =
getSupportedVulkanExternalSemaphoreHandleTypeList()[0];
VulkanSemaphore vkVk2Clsemaphore(vkDevice, vkExternalSemaphoreHandleType);
VulkanSemaphore vkCl2Vksemaphore(vkDevice, vkExternalSemaphoreHandleType);
cl_semaphore_khr clCl2Vksemaphore;
cl_semaphore_khr clVk2Clsemaphore;
void* handle1 = NULL;
void* handle2 = NULL;
int fd1, fd2;
std::vector<cl_semaphore_properties_khr> sema_props1{
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
};
std::vector<cl_semaphore_properties_khr> sema_props2{
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
};
switch (vkExternalSemaphoreHandleType)
{
#ifdef _WIN32
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
log_info(" Opaque NT handles are only supported on Windows\n");
handle1 = vkVk2Clsemaphore.getHandle(vkExternalSemaphoreHandleType);
handle2 = vkCl2Vksemaphore.getHandle(vkExternalSemaphoreHandleType);
errNum = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)handle1);
sema_props2.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props2.push_back((cl_semaphore_properties_khr)handle2);
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
log_info(" Opaque D3DKMT handles are only supported on Windows\n");
handle1 = vkVk2Clsemaphore.getHandle(vkExternalSemaphoreHandleType);
handle2 = vkCl2Vksemaphore.getHandle(vkExternalSemaphoreHandleType);
errNum = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)handle1);
sema_props2.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props2.push_back((cl_semaphore_properties_khr)handle2);
break;
#else
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
log_info(" Opaque file descriptors are not supported on Windows\n");
fd1 =
(int)vkVk2Clsemaphore.getHandle(vkExternalSemaphoreHandleType);
fd2 =
(int)vkCl2Vksemaphore.getHandle(vkExternalSemaphoreHandleType);
errNum = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props1.push_back(
(cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)fd1);
sema_props2.push_back(
(cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props2.push_back((cl_semaphore_properties_khr)fd2);
break;
#endif
default: log_error("Unsupported external memory handle type\n"); break;
}
if (CL_SUCCESS != errNum)
{
throw std::runtime_error(
"Unsupported external sempahore handle type\n ");
}
sema_props1.push_back(
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)devList[0]);
sema_props1.push_back(
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_END_KHR);
sema_props2.push_back(
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_KHR);
sema_props2.push_back((cl_semaphore_properties_khr)devList[0]);
sema_props2.push_back(
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_END_KHR);
sema_props1.push_back(0);
sema_props2.push_back(0);
// Pass NULL properties
cl_semaphore_khr cl_ext_semaphore =
clCreateSemaphoreWithPropertiesKHRptr(context, NULL, &errNum);
test_failure_error(errNum, CL_INVALID_VALUE,
"Semaphore creation must fail with CL_INVALID_VALUE "
" when properties are passed as NULL");
// Pass invalid semaphore object to wait
errNum =
clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, NULL, NULL, 0, NULL, NULL);
test_failure_error(errNum, CL_INVALID_VALUE,
"clEnqueueWaitSemaphoresKHR fails with CL_INVALID_VALUE "
"when invalid semaphore object is passed");
// Pass invalid semaphore object to signal
errNum = clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, NULL, NULL, 0, NULL,
NULL);
test_failure_error(
errNum, CL_INVALID_VALUE,
"clEnqueueSignalSemaphoresKHR fails with CL_INVALID_VALUE"
"when invalid semaphore object is passed");
// Create two semaphore objects
clVk2Clsemaphore = clCreateSemaphoreWithPropertiesKHRptr(
context, sema_props1.data(), &errNum);
test_error(errNum,
"Unable to create semaphore with valid semaphore properties");
clCl2Vksemaphore = clCreateSemaphoreWithPropertiesKHRptr(
context, sema_props2.data(), &errNum);
test_error(errNum,
"Unable to create semaphore with valid semaphore properties");
// Call Signal twice consecutively
errNum = clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, &clVk2Clsemaphore,
NULL, 0, NULL, NULL);
test_error(errNum, "clEnqueueSignalSemaphoresKHRptr failed");
errNum = clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, &clCl2Vksemaphore,
NULL, 0, NULL, NULL);
test_error(errNum,
"clEnqueueSignalSemaphoresKHRptr failed for two "
"consecutive wait events");
// Call Wait twice consecutively
errNum = clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &clVk2Clsemaphore,
NULL, 0, NULL, NULL);
test_error(errNum, "clEnqueueWaitSemaphoresKHRptr failed");
errNum = clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &clCl2Vksemaphore,
NULL, 0, NULL, NULL);
test_error(errNum,
"clEnqueueWaitSemaphoresKHRptr failed for two "
" consecutive wait events");
// Pass invalid object to release call
errNum = clReleaseSemaphoreObjectKHRptr(NULL);
test_failure_error(errNum, CL_INVALID_VALUE,
"clReleaseSemaphoreObjectKHRptr fails with "
"CL_INVALID_VALUE when NULL semaphore object is passed");
// Release both semaphore objects
errNum = clReleaseSemaphoreObjectKHRptr(clVk2Clsemaphore);
test_error(errNum, "clReleaseSemaphoreObjectKHRptr failed");
errNum = clReleaseSemaphoreObjectKHRptr(clCl2Vksemaphore);
test_error(errNum, "clReleaseSemaphoreObjectKHRptr failed");
return TEST_PASS;
}

1808
test_conformance/vulkan/test_vulkan_interop_buffer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1648
test_conformance/vulkan/test_vulkan_interop_image.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

146
test_conformance/vulkan/test_vulkan_platform_device_info.cpp Normal file
View File

@@ -0,0 +1,146 @@
//
// 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 <CL/cl.h>
#include <CL/cl_ext.h>
#include "harness/testHarness.h"
#include <iostream>
#include <string>
typedef struct
{
cl_uint info;
const char *name;
} _info;
_info platform_info_table[] = {
#define STRING(x) \
{ \
x, #x \
}
STRING(CL_PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR),
STRING(CL_PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR),
STRING(CL_PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR)
#undef STRING
};
_info device_info_table[] = {
#define STRING(x) \
{ \
x, #x \
}
STRING(CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR),
STRING(CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR),
STRING(CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR)
#undef STRING
};
int test_platform_info(cl_device_id deviceID, cl_context _context,
cl_command_queue _queue, int num_elements)
{
cl_uint num_platforms;
cl_uint i, j;
cl_platform_id *platforms;
cl_int errNum;
cl_uint *handle_type;
size_t handle_type_size = 0;
cl_uint num_handles = 0;
// get total # of platforms
errNum = clGetPlatformIDs(0, NULL, &num_platforms);
test_error(errNum, "clGetPlatformIDs (getting count) failed");
platforms =
(cl_platform_id *)malloc(num_platforms * sizeof(cl_platform_id));
if (!platforms)
{
printf("error allocating memory\n");
exit(1);
}
log_info("%d platforms available\n", num_platforms);
errNum = clGetPlatformIDs(num_platforms, platforms, NULL);
test_error(errNum, "clGetPlatformIDs (getting IDs) failed");
for (i = 0; i < num_platforms; i++)
{
log_info("Platform%d (id %lu) info:\n", i, (unsigned long)platforms[i]);
for (j = 0;
j < sizeof(platform_info_table) / sizeof(platform_info_table[0]);
j++)
{
errNum =
clGetPlatformInfo(platforms[i], platform_info_table[j].info, 0,
NULL, &handle_type_size);
test_error(errNum, "clGetPlatformInfo failed");
num_handles = handle_type_size / sizeof(cl_uint);
handle_type = (cl_uint *)malloc(handle_type_size);
errNum =
clGetPlatformInfo(platforms[i], platform_info_table[j].info,
handle_type_size, handle_type, NULL);
test_error(errNum, "clGetPlatformInfo failed");
log_info("%s: \n", platform_info_table[j].name);
while (num_handles--)
{
log_info("%x \n", handle_type[num_handles]);
}
if (handle_type)
{
free(handle_type);
}
}
}
if (platforms)
{
free(platforms);
}
return TEST_PASS;
}
int test_device_info(cl_device_id deviceID, cl_context _context,
cl_command_queue _queue, int num_elements)
{
cl_uint j;
cl_uint *handle_type;
size_t handle_type_size = 0;
cl_uint num_handles = 0;
cl_int errNum = CL_SUCCESS;
for (j = 0; j < sizeof(device_info_table) / sizeof(device_info_table[0]);
j++)
{
errNum = clGetDeviceInfo(deviceID, device_info_table[j].info, 0, NULL,
&handle_type_size);
test_error(errNum, "clGetDeviceInfo failed");
num_handles = handle_type_size / sizeof(cl_uint);
handle_type = (cl_uint *)malloc(handle_type_size);
errNum = clGetDeviceInfo(deviceID, device_info_table[j].info,
handle_type_size, handle_type, NULL);
test_error(errNum, "clGetDeviceInfo failed");
log_info("%s: \n", device_info_table[j].name);
while (num_handles--)
{
log_info("%x \n", handle_type[num_handles]);
}
if (handle_type)
{
free(handle_type);
}
}
return TEST_PASS;
}

818
test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.cpp Normal file
View File

@@ -0,0 +1,818 @@
//
// 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 <CL/cl_ext.h>
#include "opencl_vulkan_wrapper.hpp"
#include "vulkan_wrapper.hpp"
#include "harness/errorHelpers.h"
#include "harness/deviceInfo.h"
#include <assert.h>
#include <iostream>
#include <stdexcept>
#define ASSERT(x) assert((x))
pfnclCreateSemaphoreWithPropertiesKHR clCreateSemaphoreWithPropertiesKHRptr;
pfnclEnqueueWaitSemaphoresKHR clEnqueueWaitSemaphoresKHRptr;
pfnclEnqueueSignalSemaphoresKHR clEnqueueSignalSemaphoresKHRptr;
pfnclEnqueueAcquireExternalMemObjectsKHR
clEnqueueAcquireExternalMemObjectsKHRptr;
pfnclEnqueueReleaseExternalMemObjectsKHR
clEnqueueReleaseExternalMemObjectsKHRptr;
pfnclReleaseSemaphoreObjectKHR clReleaseSemaphoreObjectKHRptr;
void init_cl_vk_ext(cl_platform_id opencl_platform)
{
clEnqueueWaitSemaphoresKHRptr =
(pfnclEnqueueWaitSemaphoresKHR)clGetExtensionFunctionAddressForPlatform(
opencl_platform, "clEnqueueWaitSemaphoresKHR");
if (NULL == clEnqueueWaitSemaphoresKHRptr)
{
throw std::runtime_error("Failed to get the function pointer of "
"clEnqueueWaitSemaphoresKHRptr!");
}
clEnqueueSignalSemaphoresKHRptr = (pfnclEnqueueSignalSemaphoresKHR)
clGetExtensionFunctionAddressForPlatform(
opencl_platform, "clEnqueueSignalSemaphoresKHR");
if (NULL == clEnqueueSignalSemaphoresKHRptr)
{
throw std::runtime_error("Failed to get the function pointer of "
"clEnqueueSignalSemaphoresKHRptr!");
}
clReleaseSemaphoreObjectKHRptr = (pfnclReleaseSemaphoreObjectKHR)
clGetExtensionFunctionAddressForPlatform(opencl_platform,
"clReleaseSemaphoreObjectKHR");
if (NULL == clReleaseSemaphoreObjectKHRptr)
{
throw std::runtime_error("Failed to get the function pointer of "
"clReleaseSemaphoreObjectKHRptr!");
}
clCreateSemaphoreWithPropertiesKHRptr =
(pfnclCreateSemaphoreWithPropertiesKHR)
clGetExtensionFunctionAddressForPlatform(
opencl_platform, "clCreateSemaphoreWithPropertiesKHR");
if (NULL == clCreateSemaphoreWithPropertiesKHRptr)
{
throw std::runtime_error("Failed to get the function pointer of "
"clCreateSemaphoreWithPropertiesKHRptr!");
}
}
cl_int getCLFormatFromVkFormat(VkFormat vkFormat,
cl_image_format *clImageFormat)
{
cl_int result = CL_SUCCESS;
switch (vkFormat)
{
case VK_FORMAT_R8G8B8A8_UNORM:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
break;
case VK_FORMAT_B8G8R8A8_UNORM:
clImageFormat->image_channel_order = CL_BGRA;
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
break;
case VK_FORMAT_R16G16B16A16_UNORM:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNORM_INT16;
break;
case VK_FORMAT_R8G8B8A8_SINT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
break;
case VK_FORMAT_R16G16B16A16_SINT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_SIGNED_INT16;
break;
case VK_FORMAT_R32G32B32A32_SINT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_SIGNED_INT32;
break;
case VK_FORMAT_R8G8B8A8_UINT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
break;
case VK_FORMAT_R16G16B16A16_UINT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT16;
break;
case VK_FORMAT_R32G32B32A32_UINT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT32;
break;
case VK_FORMAT_R16G16B16A16_SFLOAT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_HALF_FLOAT;
break;
case VK_FORMAT_R32G32B32A32_SFLOAT:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_FLOAT;
break;
case VK_FORMAT_R8_SNORM:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
break;
case VK_FORMAT_R16_SNORM:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_SNORM_INT16;
break;
case VK_FORMAT_R8_UNORM:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
break;
case VK_FORMAT_R16_UNORM:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_UNORM_INT16;
break;
case VK_FORMAT_R8_SINT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
break;
case VK_FORMAT_R16_SINT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_SIGNED_INT16;
break;
case VK_FORMAT_R32_SINT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_SIGNED_INT32;
break;
case VK_FORMAT_R8_UINT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
break;
case VK_FORMAT_R16_UINT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT16;
break;
case VK_FORMAT_R32_UINT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT32;
break;
case VK_FORMAT_R16_SFLOAT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_HALF_FLOAT;
break;
case VK_FORMAT_R32_SFLOAT:
clImageFormat->image_channel_order = CL_R;
clImageFormat->image_channel_data_type = CL_FLOAT;
break;
case VK_FORMAT_R8G8_SNORM:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
break;
case VK_FORMAT_R16G16_SNORM:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_SNORM_INT16;
break;
case VK_FORMAT_R8G8_UNORM:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
break;
case VK_FORMAT_R16G16_UNORM:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_UNORM_INT16;
break;
case VK_FORMAT_R8G8_SINT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
break;
case VK_FORMAT_R16G16_SINT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_SIGNED_INT16;
break;
case VK_FORMAT_R32G32_SINT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_SIGNED_INT32;
break;
case VK_FORMAT_R8G8_UINT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
break;
case VK_FORMAT_R16G16_UINT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT16;
break;
case VK_FORMAT_R32G32_UINT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT32;
break;
case VK_FORMAT_R16G16_SFLOAT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_HALF_FLOAT;
break;
case VK_FORMAT_R32G32_SFLOAT:
clImageFormat->image_channel_order = CL_RG;
clImageFormat->image_channel_data_type = CL_FLOAT;
break;
case VK_FORMAT_R5G6B5_UNORM_PACK16:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_565;
break;
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_555;
break;
case VK_FORMAT_R8G8B8A8_SNORM:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
break;
case VK_FORMAT_R16G16B16A16_SNORM:
clImageFormat->image_channel_order = CL_RGBA;
clImageFormat->image_channel_data_type = CL_SNORM_INT16;
break;
case VK_FORMAT_B8G8R8A8_SNORM:
clImageFormat->image_channel_order = CL_BGRA;
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
break;
case VK_FORMAT_B5G6R5_UNORM_PACK16:
clImageFormat->image_channel_order = CL_BGRA;
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_565;
break;
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
clImageFormat->image_channel_order = CL_BGRA;
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_555;
break;
case VK_FORMAT_B8G8R8A8_SINT:
clImageFormat->image_channel_order = CL_BGRA;
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
break;
case VK_FORMAT_B8G8R8A8_UINT:
clImageFormat->image_channel_order = CL_BGRA;
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
break;
case VK_FORMAT_A8B8G8R8_SNORM_PACK32: result = CL_INVALID_VALUE; break;
case VK_FORMAT_A8B8G8R8_UNORM_PACK32: result = CL_INVALID_VALUE; break;
case VK_FORMAT_A8B8G8R8_SINT_PACK32: result = CL_INVALID_VALUE; break;
case VK_FORMAT_A8B8G8R8_UINT_PACK32: result = CL_INVALID_VALUE; break;
default:
log_error("Unsupported format\n");
ASSERT(0);
break;
}
return result;
}
cl_mem_object_type getImageTypeFromVk(VkImageType imageType)
{
cl_mem_object_type cl_image_type = CL_INVALID_VALUE;
switch (imageType)
{
case VK_IMAGE_TYPE_1D: cl_image_type = CL_MEM_OBJECT_IMAGE1D; break;
case VK_IMAGE_TYPE_2D: cl_image_type = CL_MEM_OBJECT_IMAGE2D; break;
case VK_IMAGE_TYPE_3D: cl_image_type = CL_MEM_OBJECT_IMAGE3D; break;
default: break;
}
return cl_image_type;
}
size_t GetElementNBytes(const cl_image_format *format)
{
size_t result;
switch (format->image_channel_order)
{
case CL_R:
case CL_A:
case CL_INTENSITY:
case CL_LUMINANCE:
case CL_DEPTH: result = 1; break;
case CL_RG:
case CL_RA: result = 2; break;
case CL_RGB: result = 3; break;
case CL_RGBA:
case CL_ARGB:
case CL_BGRA:
case CL_sRGBA: result = 4; break;
default: result = 0; break;
}
switch (format->image_channel_data_type)
{
case CL_SNORM_INT8:
case CL_UNORM_INT8:
case CL_SIGNED_INT8:
case CL_UNSIGNED_INT8:
// result *= 1;
break;
case CL_SNORM_INT16:
case CL_UNORM_INT16:
case CL_SIGNED_INT16:
case CL_UNSIGNED_INT16:
case CL_HALF_FLOAT: result *= 2; break;
case CL_SIGNED_INT32:
case CL_UNSIGNED_INT32:
case CL_FLOAT: result *= 4; break;
case CL_UNORM_SHORT_565:
case CL_UNORM_SHORT_555:
if (result == 3)
{
result = 2;
}
else
{
result = 0;
}
break;
case CL_UNORM_INT_101010:
if (result == 3)
{
result = 4;
}
else
{
result = 0;
}
break;
default: result = 0; break;
}
return result;
}
cl_int get2DImageDimensions(const VkImageCreateInfo *VulkanImageCreateInfo,
cl_image_format *img_fmt, size_t totalImageSize,
size_t &width, size_t &height)
{
cl_int result = CL_SUCCESS;
if (totalImageSize == 0)
{
result = CL_INVALID_VALUE;
}
size_t element_size = GetElementNBytes(img_fmt);
size_t row_pitch = element_size * VulkanImageCreateInfo->extent.width;
row_pitch = row_pitch % 64 == 0 ? row_pitch : ((row_pitch / 64) + 1) * 64;
width = row_pitch / element_size;
height = totalImageSize / row_pitch;
return result;
}
cl_int
getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *VulkanImageCreateInfo,
size_t totalImageSize, cl_image_format *img_fmt,
cl_image_desc *img_desc)
{
cl_int result = CL_SUCCESS;
cl_image_format clImgFormat = { 0 };
result =
getCLFormatFromVkFormat(VulkanImageCreateInfo->format, &clImgFormat);
if (CL_SUCCESS != result)
{
return result;
}
memcpy(img_fmt, &clImgFormat, sizeof(cl_image_format));
img_desc->image_type = getImageTypeFromVk(VulkanImageCreateInfo->imageType);
if (CL_INVALID_VALUE == img_desc->image_type)
{
return CL_INVALID_VALUE;
}
result =
get2DImageDimensions(VulkanImageCreateInfo, img_fmt, totalImageSize,
img_desc->image_width, img_desc->image_height);
if (CL_SUCCESS != result)
{
throw std::runtime_error("get2DImageDimensions failed!!!");
}
img_desc->image_depth = 0; // VulkanImageCreateInfo->extent.depth;
img_desc->image_array_size = 0;
img_desc->image_row_pitch = 0; // Row pitch set to zero as host_ptr is NULL
img_desc->image_slice_pitch =
img_desc->image_row_pitch * img_desc->image_height;
img_desc->num_mip_levels = 1;
img_desc->num_samples = 0;
img_desc->buffer = NULL;
return result;
}
cl_int check_external_memory_handle_type(
cl_device_id deviceID,
cl_external_memory_handle_type_khr requiredHandleType)
{
unsigned int i;
cl_external_memory_handle_type_khr *handle_type;
size_t handle_type_size = 0;
cl_int errNum = CL_SUCCESS;
errNum = clGetDeviceInfo(deviceID,
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR,
0, NULL, &handle_type_size);
handle_type =
(cl_external_memory_handle_type_khr *)malloc(handle_type_size);
errNum = clGetDeviceInfo(deviceID,
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR,
handle_type_size, handle_type, NULL);
test_error(
errNum,
"Unable to query CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR \n");
for (i = 0; i < handle_type_size; i++)
{
if (requiredHandleType == handle_type[i])
{
return CL_SUCCESS;
}
}
log_error("cl_khr_external_memory extension is missing support for %d\n",
requiredHandleType);
return CL_INVALID_VALUE;
}
cl_int check_external_semaphore_handle_type(
cl_device_id deviceID,
cl_external_semaphore_handle_type_khr requiredHandleType)
{
unsigned int i;
cl_external_semaphore_handle_type_khr *handle_type;
size_t handle_type_size = 0;
cl_int errNum = CL_SUCCESS;
errNum =
clGetDeviceInfo(deviceID, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR,
0, NULL, &handle_type_size);
handle_type =
(cl_external_semaphore_handle_type_khr *)malloc(handle_type_size);
errNum =
clGetDeviceInfo(deviceID, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR,
handle_type_size, handle_type, NULL);
test_error(
errNum,
"Unable to query CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR \n");
for (i = 0; i < handle_type_size; i++)
{
if (requiredHandleType == handle_type[i])
{
return CL_SUCCESS;
}
}
log_error("cl_khr_external_semaphore extension is missing support for %d\n",
requiredHandleType);
return CL_INVALID_VALUE;
}
clExternalMemory::clExternalMemory() {}
clExternalMemory::clExternalMemory(const clExternalMemory &externalMemory)
: m_externalMemory(externalMemory.m_externalMemory)
{}
clExternalMemory::clExternalMemory(
const VulkanDeviceMemory *deviceMemory,
VulkanExternalMemoryHandleType externalMemoryHandleType, uint64_t offset,
uint64_t size, cl_context context, cl_device_id deviceId)
{
int err = 0;
m_externalMemory = NULL;
cl_device_id devList[] = { deviceId, NULL };
std::vector<cl_mem_properties> extMemProperties;
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_memory_win32 extension\n");
}
#else
if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_memory_opaque_fd "
"extension \n");
}
#endif
switch (externalMemoryHandleType)
{
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
#ifdef _WIN32
ASSERT(0);
#endif
log_info("Opaque file descriptors are not supported on Windows\n");
fd = (int)deviceMemory->getHandle(externalMemoryHandleType);
err = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
extMemProperties.push_back(
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
extMemProperties.push_back((cl_mem_properties)fd);
break;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
#ifndef _WIN32
ASSERT(0);
#else
log_info(" Opaque NT handles are only supported on Windows\n");
handle = deviceMemory->getHandle(externalMemoryHandleType);
err = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
extMemProperties.push_back(
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
extMemProperties.push_back((cl_mem_properties)handle);
#endif
break;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
#ifndef _WIN32
ASSERT(0);
#else
log_info("Opaque D3DKMT handles are only supported on Windows\n");
handle = deviceMemory->getHandle(externalMemoryHandleType);
err = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
extMemProperties.push_back(
(cl_mem_properties)
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
extMemProperties.push_back((cl_mem_properties)handle);
#endif
break;
default:
ASSERT(0);
log_error("Unsupported external memory handle type\n");
break;
}
if (CL_SUCCESS != err)
{
throw std::runtime_error("Unsupported external memory type\n ");
}
extMemProperties.push_back((cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR);
extMemProperties.push_back((cl_mem_properties)devList[0]);
extMemProperties.push_back(
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR);
extMemProperties.push_back(0);
m_externalMemory = clCreateBufferWithProperties(
context, extMemProperties.data(), 1, size, NULL, &err);
if (CL_SUCCESS != err)
{
log_error("clCreateBufferWithProperties failed with %d\n", err);
throw std::runtime_error("clCreateBufferWithProperties failed ");
}
}
clExternalMemoryImage::clExternalMemoryImage(
const VulkanDeviceMemory &deviceMemory,
VulkanExternalMemoryHandleType externalMemoryHandleType, cl_context context,
size_t totalImageMemSize, size_t imageWidth, size_t imageHeight,
size_t totalSize, const VulkanImage2D &image2D, cl_device_id deviceId)
{
cl_int errcode_ret = 0;
std::vector<cl_mem_properties> extMemProperties1;
cl_device_id devList[] = { deviceId, NULL };
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
{
throw std::runtime_error("Device does not support "
"cl_khr_external_memory_win32 extension \n");
}
#elif !defined(__APPLE__)
if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_memory_opaque_fd "
"extension\n");
}
#endif
switch (externalMemoryHandleType)
{
#ifdef _WIN32
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
log_info("Opaque NT handles are only supported on Windows\n");
handle = deviceMemory.getHandle(externalMemoryHandleType);
errcode_ret = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
extMemProperties1.push_back(
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
extMemProperties1.push_back((cl_mem_properties)handle);
break;
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
log_info("Opaque D3DKMT handles are only supported on Windows\n");
handle = deviceMemory.getHandle(externalMemoryHandleType);
errcode_ret = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
extMemProperties1.push_back(
(cl_mem_properties)
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
extMemProperties1.push_back((cl_mem_properties)handle);
break;
#elif !defined(__APPLE__)
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
log_info(" Opaque file descriptors are not supported on Windows\n");
fd = (int)deviceMemory.getHandle(externalMemoryHandleType);
errcode_ret = check_external_memory_handle_type(
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
extMemProperties1.push_back(
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
extMemProperties1.push_back((cl_mem_properties)fd);
break;
#endif
default:
ASSERT(0);
log_error("Unsupported external memory handle type\n");
break;
}
if (CL_SUCCESS != errcode_ret)
{
throw std::runtime_error("Unsupported external memory type\n ");
}
// Set cl_image_desc
size_t clImageFormatSize;
cl_image_desc image_desc;
memset(&image_desc, 0x0, sizeof(cl_image_desc));
cl_image_format img_format = { 0 };
const VkImageCreateInfo VulkanImageCreateInfo =
image2D.getVkImageCreateInfo();
errcode_ret = getCLImageInfoFromVkImageInfo(
&VulkanImageCreateInfo, image2D.getSize(), &img_format, &image_desc);
if (CL_SUCCESS != errcode_ret)
{
throw std::runtime_error("getCLImageInfoFromVkImageInfo failed!!!");
}
extMemProperties1.push_back((cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR);
extMemProperties1.push_back((cl_mem_properties)devList[0]);
extMemProperties1.push_back(
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR);
extMemProperties1.push_back(0);
m_externalMemory = clCreateImageWithProperties(
context, extMemProperties1.data(), CL_MEM_READ_WRITE, &img_format,
&image_desc, NULL, &errcode_ret);
if (CL_SUCCESS != errcode_ret)
{
throw std::runtime_error("clCreateImageWithProperties failed!!!");
}
}
cl_mem clExternalMemory::getExternalMemoryBuffer() { return m_externalMemory; }
cl_mem clExternalMemoryImage::getExternalMemoryImage()
{
return m_externalMemory;
}
clExternalMemoryImage::~clExternalMemoryImage()
{
clReleaseMemObject(m_externalMemory);
}
clExternalMemory::~clExternalMemory() { clReleaseMemObject(m_externalMemory); }
clExternalMemoryImage::clExternalMemoryImage() {}
//////////////////////////////////////////
// clExternalSemaphore implementation //
//////////////////////////////////////////
clExternalSemaphore::clExternalSemaphore(
const clExternalSemaphore &externalSemaphore)
: m_externalSemaphore(externalSemaphore.m_externalSemaphore)
{}
clExternalSemaphore::clExternalSemaphore(
const VulkanSemaphore &semaphore, cl_context context,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType,
cl_device_id deviceId)
{
cl_int err = 0;
cl_device_id devList[] = { deviceId, NULL };
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_semaphore_win32"))
{
throw std::runtime_error("Device does not support "
"cl_khr_external_semaphore_win32 extension\n");
}
#elif !defined(__APPLE__)
if (!is_extension_available(devList[0],
"cl_khr_external_semaphore_opaque_fd"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_semaphore_opaque_fd "
"extension \n");
}
#endif
std::vector<cl_semaphore_properties_khr> sema_props{
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
};
switch (externalSemaphoreHandleType)
{
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
#ifdef _WIN32
ASSERT(0);
#else
log_info(" Opaque file descriptors are not supported on Windows\n");
fd = (int)semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props.push_back(
(cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props.push_back((cl_semaphore_properties_khr)fd);
#endif
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
#ifndef _WIN32
ASSERT(0);
#else
log_info(" Opaque NT handles are only supported on Windows\n");
handle = semaphore.getName().size()
? NULL
: semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props.push_back((cl_semaphore_properties_khr)handle);
#endif
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
#ifndef _WIN32
ASSERT(0);
#else
log_info(" Opaque D3DKMT handles are only supported on Windows\n");
handle = semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props.push_back((cl_semaphore_properties_khr)handle);
#endif
break;
default:
ASSERT(0);
log_error("Unsupported external memory handle type\n");
break;
}
if (CL_SUCCESS != err)
{
throw std::runtime_error(
"Unsupported external sempahore handle type\n ");
}
sema_props.push_back(
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_KHR);
sema_props.push_back((cl_semaphore_properties_khr)devList[0]);
sema_props.push_back(
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_END_KHR);
sema_props.push_back(0);
m_externalSemaphore =
clCreateSemaphoreWithPropertiesKHRptr(context, sema_props.data(), &err);
if (CL_SUCCESS != err)
{
log_error("clCreateSemaphoreWithPropertiesKHRptr failed with %d\n",
err);
throw std::runtime_error(
"clCreateSemaphoreWithPropertiesKHRptr failed! ");
}
}
clExternalSemaphore::~clExternalSemaphore()
{
cl_int err = clReleaseSemaphoreObjectKHRptr(m_externalSemaphore);
if (err != CL_SUCCESS)
{
throw std::runtime_error("clReleaseSemaphoreObjectKHR failed!");
}
}
void clExternalSemaphore::signal(cl_command_queue cmd_queue)
{
clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, &m_externalSemaphore, NULL, 0,
NULL, NULL);
}
void clExternalSemaphore::wait(cl_command_queue cmd_queue)
{
clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &m_externalSemaphore, NULL, 0,
NULL, NULL);
}

129
test_conformance/vulkan/vulkan_interop_common/opencl_vulkan_wrapper.hpp Normal file
View File

@@ -0,0 +1,129 @@
//
// 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 _opencl_vulkan_wrapper_hpp_
#define _opencl_vulkan_wrapper_hpp_
#include "vulkan_wrapper.hpp"
#if !defined(__APPLE__)
#include <CL/cl.h>
#include <CL/cl_ext.h>
#else
#include <OpenCL/cl.h>
#include <OpenCL/cl_ext.h>
#endif
typedef cl_semaphore_khr (*pfnclCreateSemaphoreWithPropertiesKHR)(
cl_context context, cl_semaphore_properties_khr *sema_props,
cl_int *errcode_ret);
typedef cl_int (*pfnclEnqueueWaitSemaphoresKHR)(
cl_command_queue command_queue, cl_uint num_semaphores,
const cl_semaphore_khr *sema_list,
const cl_semaphore_payload_khr *sema_payload_list,
cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
cl_event *event);
typedef cl_int (*pfnclEnqueueSignalSemaphoresKHR)(
cl_command_queue command_queue, cl_uint num_semaphores,
const cl_semaphore_khr *sema_list,
const cl_semaphore_payload_khr *sema_payload_list,
cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
cl_event *event);
typedef cl_int (*pfnclEnqueueAcquireExternalMemObjectsKHR)(
cl_command_queue command_queue, cl_uint num_mem_objects,
const cl_mem *mem_objects, cl_uint num_events_in_wait_list,
const cl_event *event_wait_list, cl_event *event);
typedef cl_int (*pfnclEnqueueReleaseExternalMemObjectsKHR)(
cl_command_queue command_queue, cl_uint num_mem_objects,
const cl_mem *mem_objects, cl_uint num_events_in_wait_list,
const cl_event *event_wait_list, cl_event *event);
typedef cl_int (*pfnclReleaseSemaphoreObjectKHR)(cl_semaphore_khr sema_object);
extern pfnclCreateSemaphoreWithPropertiesKHR
clCreateSemaphoreWithPropertiesKHRptr;
extern pfnclEnqueueWaitSemaphoresKHR clEnqueueWaitSemaphoresKHRptr;
extern pfnclEnqueueSignalSemaphoresKHR clEnqueueSignalSemaphoresKHRptr;
extern pfnclEnqueueAcquireExternalMemObjectsKHR
clEnqueueAcquireExternalMemObjectsKHRptr;
extern pfnclEnqueueReleaseExternalMemObjectsKHR
clEnqueueReleaseExternalMemObjectsKHRptr;
extern pfnclReleaseSemaphoreObjectKHR clReleaseSemaphoreObjectKHRptr;
cl_int getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *, size_t,
cl_image_format *, cl_image_desc *);
cl_int check_external_memory_handle_type(
cl_device_id deviceID,
cl_external_memory_handle_type_khr requiredHandleType);
cl_int check_external_semaphore_handle_type(
cl_device_id deviceID,
cl_external_semaphore_handle_type_khr requiredHandleType);
class clExternalMemory {
protected:
cl_mem m_externalMemory;
int fd;
void *handle;
clExternalMemory(const clExternalMemory &externalMemory);
public:
clExternalMemory();
clExternalMemory(const VulkanDeviceMemory *deviceMemory,
VulkanExternalMemoryHandleType externalMemoryHandleType,
uint64_t offset, uint64_t size, cl_context context,
cl_device_id deviceId);
virtual ~clExternalMemory();
cl_mem getExternalMemoryBuffer();
};
class clExternalMemoryImage {
protected:
cl_mem m_externalMemory;
int fd;
void *handle;
cl_command_queue cmd_queue;
clExternalMemoryImage();
public:
clExternalMemoryImage(
const VulkanDeviceMemory &deviceMemory,
VulkanExternalMemoryHandleType externalMemoryHandleType,
cl_context context, size_t totalImageMemSize, size_t imageWidth,
size_t imageHeight, size_t totalSize, const VulkanImage2D &image2D,
cl_device_id deviceId);
virtual ~clExternalMemoryImage();
cl_mem getExternalMemoryImage();
};
class clExternalSemaphore {
protected:
cl_semaphore_khr m_externalSemaphore;
int fd;
void *handle;
clExternalSemaphore(const clExternalSemaphore &externalSemaphore);
public:
clExternalSemaphore(
const VulkanSemaphore &deviceSemaphore, cl_context context,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType,
cl_device_id deviceId);
virtual ~clExternalSemaphore();
void signal(cl_command_queue command_queue);
void wait(cl_command_queue command_queue);
// operator openclExternalSemaphore_t() const;
};
extern void init_cl_vk_ext(cl_platform_id);
#endif // _opencl_vulkan_wrapper_hpp_

195
test_conformance/vulkan/vulkan_interop_common/vulkan_api_list.hpp Normal file
View File

@@ -0,0 +1,195 @@
//
// 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_api_list_hpp_
#define _vulkan_api_list_hpp_
#define VK_FUNC_LIST \
VK_FUNC_DECL(vkEnumerateInstanceVersion) \
VK_FUNC_DECL(vkEnumerateInstanceExtensionProperties) \
VK_FUNC_DECL(vkEnumerateInstanceLayerProperties) \
VK_FUNC_DECL(vkCreateInstance) \
VK_FUNC_DECL(vkGetInstanceProcAddr) \
VK_FUNC_DECL(vkGetDeviceProcAddr) \
VK_FUNC_DECL(vkEnumeratePhysicalDevices) \
VK_FUNC_DECL(vkGetPhysicalDeviceProperties) \
VK_FUNC_DECL(vkCreateDevice) \
VK_FUNC_DECL(vkDestroyDevice) \
VK_FUNC_DECL(vkGetDeviceQueue) \
VK_FUNC_DECL(vkQueueWaitIdle) \
VK_FUNC_DECL(vkCreateDescriptorSetLayout) \
VK_FUNC_DECL(vkCreatePipelineLayout) \
VK_FUNC_DECL(vkCreateShaderModule) \
VK_FUNC_DECL(vkCreateComputePipelines) \
VK_FUNC_DECL(vkCreateDescriptorPool) \
VK_FUNC_DECL(vkAllocateDescriptorSets) \
VK_FUNC_DECL(vkFreeDescriptorSets) \
VK_FUNC_DECL(vkAllocateCommandBuffers) \
VK_FUNC_DECL(vkBeginCommandBuffer) \
VK_FUNC_DECL(vkCmdBindPipeline) \
VK_FUNC_DECL(vkCmdBindDescriptorSets) \
VK_FUNC_DECL(vkCmdPipelineBarrier) \
VK_FUNC_DECL(vkCmdDispatch) \
VK_FUNC_DECL(vkCmdFillBuffer) \
VK_FUNC_DECL(vkCmdCopyBuffer) \
VK_FUNC_DECL(vkCmdUpdateBuffer) \
VK_FUNC_DECL(vkCmdCopyBufferToImage) \
VK_FUNC_DECL(vkCmdCopyImageToBuffer) \
VK_FUNC_DECL(vkEndCommandBuffer) \
VK_FUNC_DECL(vkCreateBuffer) \
VK_FUNC_DECL(vkCreateImageView) \
VK_FUNC_DECL(vkAllocateMemory) \
VK_FUNC_DECL(vkMapMemory) \
VK_FUNC_DECL(vkBindBufferMemory) \
VK_FUNC_DECL(vkBindImageMemory) \
VK_FUNC_DECL(vkUnmapMemory) \
VK_FUNC_DECL(vkFreeMemory) \
VK_FUNC_DECL(vkCreateCommandPool) \
VK_FUNC_DECL(vkResetCommandPool) \
VK_FUNC_DECL(vkDestroyCommandPool) \
VK_FUNC_DECL(vkResetCommandBuffer) \
VK_FUNC_DECL(vkFreeCommandBuffers) \
VK_FUNC_DECL(vkQueueSubmit) \
VK_FUNC_DECL(vkCmdExecuteCommands) \
VK_FUNC_DECL(vkCreateFence) \
VK_FUNC_DECL(vkDestroyFence) \
VK_FUNC_DECL(vkGetFenceStatus) \
VK_FUNC_DECL(vkResetFences) \
VK_FUNC_DECL(vkWaitForFences) \
VK_FUNC_DECL(vkCreateSemaphore) \
VK_FUNC_DECL(vkDestroySemaphore) \
VK_FUNC_DECL(vkCreateEvent) \
VK_FUNC_DECL(vkDestroyImageView) \
VK_FUNC_DECL(vkCreateImage) \
VK_FUNC_DECL(vkGetImageMemoryRequirements) \
VK_FUNC_DECL(vkDestroyImage) \
VK_FUNC_DECL(vkDestroyBuffer) \
VK_FUNC_DECL(vkDestroyPipeline) \
VK_FUNC_DECL(vkDestroyShaderModule) \
VK_FUNC_DECL(vkGetPhysicalDeviceMemoryProperties) \
VK_FUNC_DECL(vkDestroyInstance) \
VK_FUNC_DECL(vkUpdateDescriptorSets) \
VK_FUNC_DECL(vkDestroyDescriptorPool) \
VK_FUNC_DECL(vkDestroyPipelineLayout) \
VK_FUNC_DECL(vkDestroyDescriptorSetLayout) \
VK_FUNC_DECL(vkGetPhysicalDeviceQueueFamilyProperties) \
VK_FUNC_DECL(vkGetPhysicalDeviceFeatures) \
VK_FUNC_DECL(vkGetPhysicalDeviceProperties2KHR) \
VK_FUNC_DECL(vkGetBufferMemoryRequirements) \
VK_FUNC_DECL(vkGetMemoryFdKHR) \
VK_FUNC_DECL(vkGetSemaphoreFdKHR) \
VK_FUNC_DECL(vkEnumeratePhysicalDeviceGroups) \
VK_FUNC_DECL(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
VK_FUNC_DECL(vkGetPhysicalDeviceSurfaceFormatsKHR) \
VK_FUNC_DECL(vkGetPhysicalDeviceSurfacePresentModesKHR) \
VK_FUNC_DECL(vkEnumerateDeviceExtensionProperties) \
VK_FUNC_DECL(vkGetPhysicalDeviceSurfaceSupportKHR)
#define VK_WINDOWS_FUNC_LIST \
VK_FUNC_DECL(vkGetMemoryWin32HandleKHR) \
VK_FUNC_DECL(vkGetSemaphoreWin32HandleKHR)
#define vkEnumerateInstanceVersion _vkEnumerateInstanceVersion
#define vkEnumerateInstanceExtensionProperties \
_vkEnumerateInstanceExtensionProperties
#define vkEnumerateInstanceLayerProperties _vkEnumerateInstanceLayerProperties
#define vkCreateInstance _vkCreateInstance
#define vkGetInstanceProcAddr _vkGetInstanceProcAddr
#define vkGetDeviceProcAddr _vkGetDeviceProcAddr
#define vkEnumeratePhysicalDevices _vkEnumeratePhysicalDevices
#define vkGetPhysicalDeviceProperties _vkGetPhysicalDeviceProperties
#define vkCreateDevice _vkCreateDevice
#define vkDestroyDevice _vkDestroyDevice
#define vkGetDeviceQueue _vkGetDeviceQueue
#define vkQueueWaitIdle _vkQueueWaitIdle
#define vkCreateDescriptorSetLayout _vkCreateDescriptorSetLayout
#define vkCreatePipelineLayout _vkCreatePipelineLayout
#define vkCreateShaderModule _vkCreateShaderModule
#define vkCreateComputePipelines _vkCreateComputePipelines
#define vkCreateDescriptorPool _vkCreateDescriptorPool
#define vkAllocateDescriptorSets _vkAllocateDescriptorSets
#define vkFreeDescriptorSets _vkFreeDescriptorSets
#define vkAllocateCommandBuffers _vkAllocateCommandBuffers
#define vkBeginCommandBuffer _vkBeginCommandBuffer
#define vkCmdBindPipeline _vkCmdBindPipeline
#define vkCmdBindDescriptorSets _vkCmdBindDescriptorSets
#define vkCmdPipelineBarrier _vkCmdPipelineBarrier
#define vkCmdDispatch _vkCmdDispatch
#define vkCmdFillBuffer _vkCmdFillBuffer
#define vkCmdCopyBuffer _vkCmdCopyBuffer
#define vkCmdUpdateBuffer _vkCmdUpdateBuffer
#define vkCmdCopyBufferToImage _vkCmdCopyBufferToImage
#define vkCmdCopyImageToBuffer _vkCmdCopyImageToBuffer
#define vkEndCommandBuffer _vkEndCommandBuffer
#define vkCreateBuffer _vkCreateBuffer
#define vkCreateImageView _vkCreateImageView
#define vkAllocateMemory _vkAllocateMemory
#define vkMapMemory _vkMapMemory
#define vkBindBufferMemory _vkBindBufferMemory
#define vkBindImageMemory _vkBindImageMemory
#define vkUnmapMemory _vkUnmapMemory
#define vkFreeMemory _vkFreeMemory
#define vkCreateCommandPool _vkCreateCommandPool
#define vkResetCommandPool _vkResetCommandPool
#define vkDestroyCommandPool _vkDestroyCommandPool
#define vkResetCommandBuffer _vkResetCommandBuffer
#define vkFreeCommandBuffers _vkFreeCommandBuffers
#define vkQueueSubmit _vkQueueSubmit
#define vkCmdExecuteCommands _vkCmdExecuteCommands
#define vkCreateFence _vkCreateFence
#define vkDestroyFence _vkDestroyFence
#define vkGetFenceStatus _vkGetFenceStatus
#define vkResetFences _vkResetFences
#define vkWaitForFences _vkWaitForFences
#define vkCreateSemaphore _vkCreateSemaphore
#define vkDestroySemaphore _vkDestroySemaphore
#define vkCreateEvent _vkCreateEvent
#define vkDestroyImageView _vkDestroyImageView
#define vkCreateImage _vkCreateImage
#define vkGetImageMemoryRequirements _vkGetImageMemoryRequirements
#define vkDestroyImage _vkDestroyImage
#define vkDestroyBuffe _vkDestroyBuffer
#define vkDestroyPipeline _vkDestroyPipeline
#define vkDestroyShaderModule _vkDestroyShaderModule
#define vkGetPhysicalDeviceMemoryProperties _vkGetPhysicalDeviceMemoryProperties
#define vkDestroyInstance _vkDestroyInstance
#define vkUpdateDescriptorSets _vkUpdateDescriptorSets
#define vkDestroyDescriptorPool _vkDestroyDescriptorPool
#define vkDestroyPipelineLayout _vkDestroyPipelineLayout
#define vkDestroyDescriptorSetLayout _vkDestroyDescriptorSetLayout
#define vkGetPhysicalDeviceQueueFamilyProperties \
_vkGetPhysicalDeviceQueueFamilyProperties
#define vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures
#define vkGetPhysicalDeviceProperties2KHR _vkGetPhysicalDeviceProperties2KHR
#define vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements
#define vkGetMemoryFdKHR _vkGetMemoryFdKHR
#define vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR
#define vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups
#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR \
_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
#define vkGetPhysicalDeviceSurfaceFormatsKHR \
_vkGetPhysicalDeviceSurfaceFormatsKHR
#define vkGetPhysicalDeviceSurfacePresentModesKHR \
_vkGetPhysicalDeviceSurfacePresentModesKHR
#define vkEnumerateDeviceExtensionProperties \
_vkEnumerateDeviceExtensionProperties
#define vkGetPhysicalDeviceSurfaceSupportKHR \
_vkGetPhysicalDeviceSurfaceSupportKHR
#define vkGetMemoryWin32HandleKHR _vkGetMemoryWin32HandleKHR
#define vkGetSemaphoreWin32HandleKHR _vkGetSemaphoreWin32HandleKHR
#endif //_vulkan_api_list_hpp_

22
test_conformance/vulkan/vulkan_interop_common/vulkan_interop_common.cpp Normal file
View File

@@ -0,0 +1,22 @@
//
// 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 "vulkan_interop_common.hpp"
uint32_t innerIterations(5);
uint32_t perfIterations(100);
uint32_t stressIterations(1000);
size_t cpuThreadsPerGpu(3);

50
test_conformance/vulkan/vulkan_interop_common/vulkan_interop_common.hpp Normal file
View File

@@ -0,0 +1,50 @@
//
// 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_interop_common_hpp_
#define _vulkan_interop_common_hpp_
#include "vulkan_wrapper_types.hpp"
#include "vulkan_wrapper.hpp"
#include "vulkan_list_map.hpp"
#include "vulkan_utility.hpp"
#include "opencl_vulkan_wrapper.hpp"
// Number of iterations for loops within tests (default value 5)
extern unsigned int innerIterations;
// Number of iterations for loops within perf tests (default value 100)
extern unsigned int perfIterations;
// Number of iterations for loops within stress tests (default value 1000)
extern unsigned int stressIterations;
// Number of CPU threads per GPU (default value 3)
extern size_t cpuThreadsPerGpu;
// Number of command queues (default value 1)
extern unsigned int numCQ;
// Enable Multi-import of vulkan device memory
extern bool multiImport;
// Enable Multi-import of vulkan device memory under different context
extern bool multiCtx;
// Enable additional debug info logging
extern bool debug_trace;
extern bool useSingleImageKernel;
extern bool useDeviceLocal;
extern bool disableNTHandleType;
// Enable offset for multiImport of vulkan device memory
extern bool enableOffset;
extern bool non_dedicated;
#endif // _vulkan_interop_common_hpp_

424
test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp Normal file
View File

@@ -0,0 +1,424 @@
//
// 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.
//
#ifdef _WIN32
#define NOMINMAX
#endif
#include "vulkan_list_map.hpp"
#include "vulkan_utility.hpp"
#include "vulkan_wrapper.hpp"
/////////////////////////////////////////////
// VulkanPhysicalDeviceList implementation //
/////////////////////////////////////////////
VulkanPhysicalDeviceList::VulkanPhysicalDeviceList(
const VulkanPhysicalDeviceList &physicalDeviceList)
{}
VulkanPhysicalDeviceList::VulkanPhysicalDeviceList() {}
VulkanPhysicalDeviceList::~VulkanPhysicalDeviceList() {}
/////////////////////////////////////////
// VulkanMemoryHeapList implementation //
/////////////////////////////////////////
VulkanMemoryHeapList::VulkanMemoryHeapList(
const VulkanMemoryHeapList &memoryHeapList)
{}
VulkanMemoryHeapList::VulkanMemoryHeapList() {}
VulkanMemoryHeapList::~VulkanMemoryHeapList() {}
/////////////////////////////////////////
// VulkanMemoryTypeList implementation //
/////////////////////////////////////////
VulkanMemoryTypeList::VulkanMemoryTypeList(
const VulkanMemoryTypeList &memoryTypeList)
{}
VulkanMemoryTypeList::VulkanMemoryTypeList() {}
VulkanMemoryTypeList::~VulkanMemoryTypeList() {}
//////////////////////////////////////////
// VulkanQueueFamilyList implementation //
//////////////////////////////////////////
VulkanQueueFamilyList::VulkanQueueFamilyList(
const VulkanQueueFamilyList &queueFamilyList)
{}
VulkanQueueFamilyList::VulkanQueueFamilyList() {}
VulkanQueueFamilyList::~VulkanQueueFamilyList() {}
/////////////////////////////////////////////////////
// VulkanQueueFamilyToQueueCountMap implementation //
/////////////////////////////////////////////////////
VulkanQueueFamilyToQueueCountMap::VulkanQueueFamilyToQueueCountMap(
const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap)
{}
VulkanQueueFamilyToQueueCountMap::VulkanQueueFamilyToQueueCountMap(
uint32_t numQueuesPerFamily)
{
uint32_t maxQueueFamilyCount = 0;
const VulkanPhysicalDeviceList &physicalDeviceList =
getVulkanInstance().getPhysicalDeviceList();
for (size_t pdIdx = 0; pdIdx < physicalDeviceList.size(); pdIdx++)
{
maxQueueFamilyCount = std::max(
maxQueueFamilyCount,
(uint32_t)physicalDeviceList[pdIdx].getQueueFamilyList().size());
}
for (uint32_t qfIdx = 0; qfIdx < maxQueueFamilyCount; qfIdx++)
{
insert(qfIdx, numQueuesPerFamily);
}
}
VulkanQueueFamilyToQueueCountMap::~VulkanQueueFamilyToQueueCountMap() {}
////////////////////////////////////////////////////
// VulkanQueueFamilyToQueueListMap implementation //
////////////////////////////////////////////////////
VulkanQueueFamilyToQueueListMap::VulkanQueueFamilyToQueueListMap(
const VulkanQueueFamilyToQueueListMap &queueFamilyToQueueMap)
{}
VulkanQueueFamilyToQueueListMap::VulkanQueueFamilyToQueueListMap() {}
VulkanQueueFamilyToQueueListMap::~VulkanQueueFamilyToQueueListMap() {}
void VulkanQueueFamilyToQueueListMap::insert(uint32_t key,
VulkanQueueList &queueList)
{
m_map.insert(std::pair<uint32_t, std::reference_wrapper<VulkanQueueList>>(
key, std::reference_wrapper<VulkanQueueList>(queueList)));
}
VulkanQueueList &VulkanQueueFamilyToQueueListMap::operator[](uint32_t key)
{
return m_map.at(key).get();
}
////////////////////////////////////
// VulkanQueueList implementation //
////////////////////////////////////
VulkanQueueList::VulkanQueueList(const VulkanQueueList &queueList) {}
VulkanQueueList::VulkanQueueList() {}
VulkanQueueList::~VulkanQueueList() {}
/////////////////////////////////////////////////////////
// VulkanDescriptorSetLayoutBindingList implementation //
/////////////////////////////////////////////////////////
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
const VulkanDescriptorSetLayoutBindingList &descriptorSetLayoutBindingList)
{}
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList() {}
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
size_t numDescriptorSetLayoutBindings, VulkanDescriptorType descriptorType,
uint32_t descriptorCount, VulkanShaderStage shaderStage)
{
for (size_t idx = 0; idx < numDescriptorSetLayoutBindings; idx++)
{
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding =
new VulkanDescriptorSetLayoutBinding((uint32_t)idx, descriptorType,
descriptorCount, shaderStage);
add(*descriptorSetLayoutBinding);
}
}
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
VulkanDescriptorType descriptorType0, uint32_t descriptorCount0,
VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
VulkanShaderStage shaderStage)
{
for (uint32_t idx = 0; idx < descriptorCount0; idx++)
{
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding0 =
new VulkanDescriptorSetLayoutBinding(idx, descriptorType0, 1,
shaderStage);
add(*descriptorSetLayoutBinding0);
}
for (uint32_t idx = 0; idx < descriptorCount1; idx++)
{
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding1 =
new VulkanDescriptorSetLayoutBinding(
descriptorCount0 + idx, descriptorType1, 1, shaderStage);
add(*descriptorSetLayoutBinding1);
}
}
VulkanDescriptorSetLayoutBindingList::~VulkanDescriptorSetLayoutBindingList()
{
for (size_t idx = 0; idx < m_wrapperList.size(); idx++)
{
VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding =
m_wrapperList[idx];
delete &descriptorSetLayoutBinding;
}
}
//////////////////////////////////////////////////
// VulkanDescriptorSetLayoutList implementation //
//////////////////////////////////////////////////
VulkanDescriptorSetLayoutList::VulkanDescriptorSetLayoutList(
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList)
{}
VulkanDescriptorSetLayoutList::VulkanDescriptorSetLayoutList() {}
VulkanDescriptorSetLayoutList::~VulkanDescriptorSetLayoutList() {}
////////////////////////////////////////////
// VulkanCommandBufferList implementation //
////////////////////////////////////////////
VulkanCommandBufferList::VulkanCommandBufferList(
const VulkanCommandBufferList &commandBufferList)
{}
VulkanCommandBufferList::VulkanCommandBufferList() {}
VulkanCommandBufferList::VulkanCommandBufferList(
size_t numCommandBuffers, const VulkanDevice &device,
const VulkanCommandPool &commandPool)
{
for (size_t idx = 0; idx < numCommandBuffers; idx++)
{
VulkanCommandBuffer *commandBuffer =
new VulkanCommandBuffer(device, commandPool);
add(*commandBuffer);
}
}
VulkanCommandBufferList::~VulkanCommandBufferList()
{
for (size_t idx = 0; idx < m_wrapperList.size(); idx++)
{
VulkanCommandBuffer &commandBuffer = m_wrapperList[idx];
delete &commandBuffer;
}
}
/////////////////////////////////////
// VulkanBufferList implementation //
/////////////////////////////////////
VulkanBufferList::VulkanBufferList(const VulkanBufferList &bufferList) {}
VulkanBufferList::VulkanBufferList(
size_t numBuffers, const VulkanDevice &device, uint64_t size,
VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanBufferUsage bufferUsage, VulkanSharingMode sharingMode,
const VulkanQueueFamilyList &queueFamilyList)
{
for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
{
VulkanBuffer *buffer =
new VulkanBuffer(device, size, externalMemoryHandleType,
bufferUsage, sharingMode, queueFamilyList);
add(*buffer);
}
}
VulkanBufferList::~VulkanBufferList()
{
for (size_t bIdx = 0; bIdx < m_wrapperList.size(); bIdx++)
{
VulkanBuffer &buffer = m_wrapperList[bIdx];
delete &buffer;
}
}
//////////////////////////////////////
// VulkanImage2DList implementation //
//////////////////////////////////////
VulkanImage2DList::VulkanImage2DList(const VulkanImage2DList &image2DList) {}
VulkanImage2DList::VulkanImage2DList(
size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
uint64_t baseOffset, uint64_t interImageOffset, const VulkanDevice &device,
VulkanFormat format, uint32_t width, uint32_t height, uint32_t mipLevels,
VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode)
{
for (size_t i2DIdx = 0; i2DIdx < numImages; i2DIdx++)
{
VulkanImage2D *image2D = new VulkanImage2D(
device, format, width, height, mipLevels, externalMemoryHandleType,
imageCreateFlag, imageUsage, sharingMode);
add(*image2D);
deviceMemory[i2DIdx]->bindImage(
*image2D, baseOffset + (i2DIdx * interImageOffset));
}
}
VulkanImage2DList::VulkanImage2DList(
size_t numImages, const VulkanDevice &device, VulkanFormat format,
uint32_t width, uint32_t height, uint32_t mipLevels,
VulkanExternalMemoryHandleType externalMemoryHandleType,
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
VulkanSharingMode sharingMode)
{
for (size_t bIdx = 0; bIdx < numImages; bIdx++)
{
VulkanImage2D *image2D = new VulkanImage2D(
device, format, width, height, mipLevels, externalMemoryHandleType,
imageCreateFlag, imageUsage, sharingMode);
add(*image2D);
}
}
VulkanImage2DList::~VulkanImage2DList()
{
for (size_t i2DIdx = 0; i2DIdx < m_wrapperList.size(); i2DIdx++)
{
VulkanImage2D &image2D = m_wrapperList[i2DIdx];
delete &image2D;
}
}
////////////////////////////////////////
// VulkanImageViewList implementation //
////////////////////////////////////////
VulkanImageViewList::VulkanImageViewList(const VulkanImageViewList &image2DList)
{}
VulkanImageViewList::VulkanImageViewList(const VulkanDevice &device,
const VulkanImage2DList &image2DList,
bool createImageViewPerMipLevel)
{
for (size_t i2DIdx = 0; i2DIdx < image2DList.size(); i2DIdx++)
{
if (createImageViewPerMipLevel)
{
for (uint32_t mipLevel = 0;
mipLevel < image2DList[i2DIdx].getNumMipLevels(); mipLevel++)
{
VulkanImageView *image2DView =
new VulkanImageView(device, image2DList[i2DIdx],
VULKAN_IMAGE_VIEW_TYPE_2D, mipLevel, 1);
add(*image2DView);
}
}
else
{
VulkanImageView *image2DView = new VulkanImageView(
device, image2DList[i2DIdx], VULKAN_IMAGE_VIEW_TYPE_2D);
add(*image2DView);
}
}
}
VulkanImageViewList::~VulkanImageViewList()
{
for (size_t ivIdx = 0; ivIdx < m_wrapperList.size(); ivIdx++)
{
VulkanImageView &imageView = m_wrapperList[ivIdx];
delete &imageView;
}
}
///////////////////////////////////////////
// VulkanDeviceMemoryList implementation //
///////////////////////////////////////////
VulkanDeviceMemoryList::VulkanDeviceMemoryList(
const VulkanDeviceMemoryList &deviceMemoryList)
{}
VulkanDeviceMemoryList::VulkanDeviceMemoryList(
size_t numImages, const VulkanImage2DList &image2DList,
const VulkanDevice &device, const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType)
{
for (size_t i2DIdx = 0; i2DIdx < image2DList.size(); i2DIdx++)
{
VulkanDeviceMemory *deviceMemory = new VulkanDeviceMemory(
device, image2DList[i2DIdx], memoryType, externalMemoryHandleType);
add(*deviceMemory);
deviceMemory->bindImage(image2DList[i2DIdx]);
}
}
VulkanDeviceMemoryList::~VulkanDeviceMemoryList()
{
for (size_t dmIdx = 0; dmIdx < m_wrapperList.size(); dmIdx++)
{
VulkanDeviceMemory &deviceMemory = m_wrapperList[dmIdx];
delete &deviceMemory;
}
}
////////////////////////////////////////
// VulkanSemaphoreList implementation //
////////////////////////////////////////
VulkanSemaphoreList::VulkanSemaphoreList(
const VulkanSemaphoreList &semaphoreList)
{}
VulkanSemaphoreList::VulkanSemaphoreList() {}
VulkanSemaphoreList::VulkanSemaphoreList(
size_t numSemaphores, const VulkanDevice &device,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType,
const std::wstring namePrefix)
{
std::wstring name = L"";
for (size_t idx = 0; idx < numSemaphores; idx++)
{
if (namePrefix.size())
{
const size_t maxNameSize = 256;
wchar_t tempName[maxNameSize];
swprintf(tempName, maxNameSize, L"%s%d", namePrefix.c_str(),
(int)idx);
name = tempName;
}
VulkanSemaphore *semaphore =
new VulkanSemaphore(device, externalSemaphoreHandleType, name);
add(*semaphore);
}
}
VulkanSemaphoreList::~VulkanSemaphoreList()
{
for (size_t idx = 0; idx < m_wrapperList.size(); idx++)
{
VulkanSemaphore &Semaphore = m_wrapperList[idx];
delete &Semaphore;
}
}

389
test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.hpp Normal file
View File

@@ -0,0 +1,389 @@
//
// 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_list_map_hpp_
#define _vulkan_list_map_hpp_
#include <functional>
#include "vulkan_wrapper_types.hpp"
#include "vulkan_utility.hpp"
#include <iostream>
template <class VulkanWrapper, class VulkanNative> class VulkanList {
protected:
std::vector<std::reference_wrapper<VulkanWrapper>> m_wrapperList;
std::vector<std::reference_wrapper<const VulkanWrapper>> m_constWrapperList;
std::vector<VulkanNative> m_nativeList;
VulkanList(const VulkanList &list);
VulkanList();
virtual ~VulkanList();
virtual void add(VulkanWrapper &wrapper);
public:
virtual void add(const VulkanWrapper &wrapper);
virtual size_t size() const;
virtual const VulkanWrapper &operator[](size_t idx) const;
virtual VulkanWrapper &operator[](size_t idx);
virtual operator const VulkanNative *() const;
};
template <class VulkanKey, class VulkanValue> class VulkanMap {
protected:
std::map<VulkanKey, VulkanValue> m_map;
VulkanMap(const VulkanMap &map);
VulkanMap();
virtual ~VulkanMap();
public:
void insert(const VulkanKey &key, VulkanValue &value);
const VulkanValue &operator[](const VulkanKey &key) const;
VulkanValue &operator[](const VulkanKey &key);
};
class VulkanPhysicalDeviceList
: public VulkanList<VulkanPhysicalDevice, VkPhysicalDevice> {
friend class VulkanInstance;
protected:
VulkanPhysicalDeviceList(
const VulkanPhysicalDeviceList &physicalDeviceList);
public:
VulkanPhysicalDeviceList();
virtual ~VulkanPhysicalDeviceList();
};
class VulkanQueueFamilyList : public VulkanList<VulkanQueueFamily, uint32_t> {
friend class VulkanPhysicalDevice;
protected:
VulkanQueueFamilyList(const VulkanQueueFamilyList &queueFamilyList);
public:
VulkanQueueFamilyList();
virtual ~VulkanQueueFamilyList();
};
class VulkanMemoryHeapList : public VulkanList<VulkanMemoryHeap, uint32_t> {
friend class VulkanPhysicalDevice;
protected:
VulkanMemoryHeapList(const VulkanMemoryHeapList &memoryHeapList);
public:
VulkanMemoryHeapList();
virtual ~VulkanMemoryHeapList();
};
class VulkanMemoryTypeList : public VulkanList<VulkanMemoryType, uint32_t> {
friend class VulkanPhysicalDevice;
friend class VulkanBuffer;
friend class VulkanImage;
protected:
VulkanMemoryTypeList(const VulkanMemoryTypeList &memoryTypeList);
public:
VulkanMemoryTypeList();
virtual ~VulkanMemoryTypeList();
};
class VulkanQueueFamilyToQueueCountMap : public VulkanMap<uint32_t, uint32_t> {
protected:
VulkanQueueFamilyToQueueCountMap(
const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap);
public:
VulkanQueueFamilyToQueueCountMap(uint32_t numQueuesPerFamily = 0);
virtual ~VulkanQueueFamilyToQueueCountMap();
};
class VulkanQueueList : public VulkanList<VulkanQueue, VkQueue> {
friend class VulkanDevice;
protected:
VulkanQueueList(const VulkanQueueList &queueList);
public:
VulkanQueueList();
virtual ~VulkanQueueList();
};
class VulkanQueueFamilyToQueueListMap
: public VulkanMap<uint32_t, std::reference_wrapper<VulkanQueueList>> {
protected:
VulkanQueueFamilyToQueueListMap(
const VulkanQueueFamilyToQueueListMap &queueFamilyToQueueMap);
public:
VulkanQueueFamilyToQueueListMap();
virtual ~VulkanQueueFamilyToQueueListMap();
void insert(uint32_t key, VulkanQueueList &queueList);
VulkanQueueList &operator[](uint32_t key);
};
class VulkanDescriptorSetLayoutBindingList
: public VulkanList<VulkanDescriptorSetLayoutBinding,
VkDescriptorSetLayoutBinding> {
protected:
VulkanDescriptorSetLayoutBindingList(
const VulkanDescriptorSetLayoutBindingList
&descriptorSetLayoutBindingList);
public:
VulkanDescriptorSetLayoutBindingList();
VulkanDescriptorSetLayoutBindingList(
size_t numDescriptorSetLayoutBindings,
VulkanDescriptorType descriptorType, uint32_t descriptorCount = 1,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
VulkanDescriptorSetLayoutBindingList(
VulkanDescriptorType descriptorType0, uint32_t descriptorCount0,
VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
virtual ~VulkanDescriptorSetLayoutBindingList();
};
class VulkanDescriptorSetLayoutList
: public VulkanList<VulkanDescriptorSetLayout, VkDescriptorSetLayout> {
protected:
VulkanDescriptorSetLayoutList(
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList);
public:
VulkanDescriptorSetLayoutList();
virtual ~VulkanDescriptorSetLayoutList();
};
class VulkanCommandBufferList
: public VulkanList<VulkanCommandBuffer, VkCommandBuffer> {
protected:
VulkanCommandBufferList(const VulkanCommandBufferList &commandBufferList);
public:
VulkanCommandBufferList();
VulkanCommandBufferList(size_t numCommandBuffers,
const VulkanDevice &device,
const VulkanCommandPool &commandPool);
virtual ~VulkanCommandBufferList();
};
class VulkanBufferList : public VulkanList<VulkanBuffer, VkBuffer> {
protected:
VulkanBufferList(const VulkanBufferList &bufferList);
public:
VulkanBufferList(
size_t numBuffers, const VulkanDevice &device, uint64_t size,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanBufferUsage bufferUsage =
VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST,
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE,
const VulkanQueueFamilyList &queueFamilyList =
getEmptyVulkanQueueFamilyList());
virtual ~VulkanBufferList();
};
class VulkanImage2DList : public VulkanList<VulkanImage2D, VkImage> {
protected:
VulkanImage2DList(const VulkanImage2DList &image2DList);
public:
VulkanImage2DList(
size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
uint64_t baseOffset, uint64_t interImageOffset,
const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t mipLevels,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
VulkanImageUsage imageUsage =
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
VulkanImage2DList(
size_t numImages, const VulkanDevice &device, VulkanFormat format,
uint32_t width, uint32_t height, uint32_t mipLevels = 1,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
VulkanImageUsage imageUsage =
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
virtual ~VulkanImage2DList();
};
class VulkanImageViewList : public VulkanList<VulkanImageView, VkImageView> {
protected:
VulkanImageViewList(const VulkanImageViewList &imageViewList);
public:
VulkanImageViewList(const VulkanDevice &device,
const VulkanImage2DList &image2DList,
bool createImageViewPerMipLevel = true);
virtual ~VulkanImageViewList();
};
class VulkanDeviceMemoryList
: public VulkanList<VulkanDeviceMemory, VkDeviceMemory> {
protected:
VulkanDeviceMemoryList(const VulkanDeviceMemoryList &deviceMemoryList);
public:
VulkanDeviceMemoryList(
size_t numImages, const VulkanImage2DList &image2DList,
const VulkanDevice &device, const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE);
virtual ~VulkanDeviceMemoryList();
};
class VulkanSemaphoreList : public VulkanList<VulkanSemaphore, VkSemaphore> {
protected:
VulkanSemaphoreList(const VulkanSemaphoreList &semaphoreList);
public:
VulkanSemaphoreList();
VulkanSemaphoreList(
size_t numSemaphores, const VulkanDevice &device,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType =
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE,
const std::wstring namePrefix = L"");
virtual ~VulkanSemaphoreList();
};
///////////////////////////////
// VulkanList implementation //
///////////////////////////////
template <class VulkanWrapper, class VulkanNative>
VulkanList<VulkanWrapper, VulkanNative>::VulkanList(const VulkanList &list)
: m_wrapperList(list.m_wrapperList),
m_constWrapperList(list.m_constWrapperList),
m_nativeList(list.m_nativeList)
{}
template <class VulkanWrapper, class VulkanNative>
VulkanList<VulkanWrapper, VulkanNative>::VulkanList()
{}
template <class VulkanWrapper, class VulkanNative>
VulkanList<VulkanWrapper, VulkanNative>::~VulkanList()
{}
template <class VulkanWrapper, class VulkanNative>
void VulkanList<VulkanWrapper, VulkanNative>::add(VulkanWrapper &wrapper)
{
if (m_constWrapperList.size() != size_t(0))
{
std::cout << "This list can only contain externally allocated objects"
<< std::endl;
return;
}
m_wrapperList.push_back(std::reference_wrapper<VulkanWrapper>(wrapper));
m_nativeList.push_back((VulkanNative)wrapper);
}
template <class VulkanWrapper, class VulkanNative>
void VulkanList<VulkanWrapper, VulkanNative>::add(const VulkanWrapper &wrapper)
{
if (m_wrapperList.size() != size_t(0))
{
std::cout << "This list cannot contain externally allocated objects"
<< std::endl;
return;
}
m_constWrapperList.push_back(
std::reference_wrapper<const VulkanWrapper>(wrapper));
m_nativeList.push_back((VulkanNative)wrapper);
}
template <class VulkanWrapper, class VulkanNative>
size_t VulkanList<VulkanWrapper, VulkanNative>::size() const
{
return (m_wrapperList.size() > 0) ? m_wrapperList.size()
: m_constWrapperList.size();
}
template <class VulkanWrapper, class VulkanNative>
const VulkanWrapper &
VulkanList<VulkanWrapper, VulkanNative>::operator[](size_t idx) const
{
if (idx < size())
{
// CHECK_LT(idx, size());
return (m_wrapperList.size() > 0) ? m_wrapperList[idx].get()
: m_constWrapperList[idx].get();
}
}
template <class VulkanWrapper, class VulkanNative>
VulkanWrapper &VulkanList<VulkanWrapper, VulkanNative>::operator[](size_t idx)
{
if (idx < m_wrapperList.size())
{
// CHECK_LT(idx, m_wrapperList.size());
return m_wrapperList[idx].get();
}
}
template <class VulkanWrapper, class VulkanNative>
VulkanList<VulkanWrapper, VulkanNative>::operator const VulkanNative *() const
{
return m_nativeList.data();
}
//////////////////////////////
// VulkanMap implementation //
//////////////////////////////
template <class VulkanKey, class VulkanValue>
VulkanMap<VulkanKey, VulkanValue>::VulkanMap(const VulkanMap &map)
: m_map(map.m_map)
{}
template <class VulkanKey, class VulkanValue>
VulkanMap<VulkanKey, VulkanValue>::VulkanMap()
{}
template <class VulkanKey, class VulkanValue>
VulkanMap<VulkanKey, VulkanValue>::~VulkanMap()
{}
template <class VulkanKey, class VulkanValue>
void VulkanMap<VulkanKey, VulkanValue>::insert(const VulkanKey &key,
VulkanValue &value)
{
m_map.insert(std::pair<VulkanKey, std::reference_wrapper<VulkanValue>>(
key, std::reference_wrapper<VulkanValue>(value)));
}
template <class VulkanKey, class VulkanValue>
const VulkanValue &
VulkanMap<VulkanKey, VulkanValue>::operator[](const VulkanKey &key) const
{
return m_map.at(key);
}
template <class VulkanKey, class VulkanValue>
VulkanValue &VulkanMap<VulkanKey, VulkanValue>::operator[](const VulkanKey &key)
{
return m_map.at(key);
}
#endif // _vulkan_list_map_hpp_

693
test_conformance/vulkan/vulkan_interop_common/vulkan_utility.cpp Normal file
View File

@@ -0,0 +1,693 @@
//
// 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 "vulkan_utility.hpp"
#include "vulkan_wrapper.hpp"
#include <assert.h>
#include <iostream>
#include <set>
#include <string>
#include <CL/cl.h>
#include <CL/cl_ext.h>
#if defined(_WIN32) || defined(_WIN64)
#include <versionhelpers.h>
#endif
#define ASSERT(x) assert((x))
#define BUFFERSIZE 3000
const VulkanInstance &getVulkanInstance()
{
static VulkanInstance instance;
return instance;
}
const VulkanPhysicalDevice &getVulkanPhysicalDevice()
{
size_t pdIdx;
cl_int errNum = 0;
cl_platform_id platform = NULL;
cl_uchar uuid[CL_UUID_SIZE_KHR];
cl_device_id *devices;
char *extensions = NULL;
size_t extensionSize = 0;
cl_uint num_devices = 0;
cl_uint device_no = 0;
const size_t bufsize = BUFFERSIZE;
char buf[BUFFERSIZE];
const VulkanInstance &instance = getVulkanInstance();
const VulkanPhysicalDeviceList &physicalDeviceList =
instance.getPhysicalDeviceList();
// get the platform ID
errNum = clGetPlatformIDs(1, &platform, NULL);
if (errNum != CL_SUCCESS)
{
printf("Error: Failed to get platform\n");
throw std::runtime_error("Error: Failed to get number of platform\n");
}
errNum =
clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &num_devices);
if (CL_SUCCESS != errNum)
{
throw std::runtime_error(
"Error: clGetDeviceIDs failed in returning of devices\n");
}
devices = (cl_device_id *)malloc(num_devices * sizeof(cl_device_id));
if (NULL == devices)
{
throw std::runtime_error(
"Error: Unable to allocate memory for devices\n");
}
errNum = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, num_devices, devices,
NULL);
if (CL_SUCCESS != errNum)
{
throw std::runtime_error("Error: Failed to get deviceID.\n");
}
bool is_selected = false;
for (device_no = 0; device_no < num_devices; device_no++)
{
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS, 0,
NULL, &extensionSize);
if (CL_SUCCESS != errNum)
{
throw std::runtime_error("Error in clGetDeviceInfo for getting "
"device_extension size....\n");
}
extensions = (char *)malloc(extensionSize);
if (NULL == extensions)
{
throw std::runtime_error(
"Unable to allocate memory for extensions\n");
}
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS,
extensionSize, extensions, NULL);
if (CL_SUCCESS != errNum)
{
throw std::runtime_error("Error: Error in clGetDeviceInfo for "
"getting device_extension\n");
}
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_UUID_KHR,
CL_UUID_SIZE_KHR, uuid, &extensionSize);
if (CL_SUCCESS != errNum)
{
throw std::runtime_error(
"Error: clGetDeviceInfo failed with error\n");
}
free(extensions);
for (pdIdx = 0; pdIdx < physicalDeviceList.size(); pdIdx++)
{
if (!memcmp(&uuid, physicalDeviceList[pdIdx].getUUID(),
VK_UUID_SIZE))
{
std::cout << "Selected physical device = "
<< physicalDeviceList[pdIdx] << std::endl;
is_selected = true;
break;
}
}
if (is_selected)
{
break;
}
}
if ((pdIdx >= physicalDeviceList.size())
|| (physicalDeviceList[pdIdx] == (VkPhysicalDevice)VK_NULL_HANDLE))
{
throw std::runtime_error("failed to find a suitable GPU!");
}
std::cout << "Selected physical device is: " << physicalDeviceList[pdIdx]
<< std::endl;
return physicalDeviceList[pdIdx];
}
const VulkanQueueFamily &getVulkanQueueFamily(uint32_t queueFlags)
{
size_t qfIdx;
const VulkanPhysicalDevice &physicalDevice = getVulkanPhysicalDevice();
const VulkanQueueFamilyList &queueFamilyList =
physicalDevice.getQueueFamilyList();
for (qfIdx = 0; qfIdx < queueFamilyList.size(); qfIdx++)
{
if ((queueFamilyList[qfIdx].getQueueFlags() & queueFlags) == queueFlags)
{
break;
}
}
return queueFamilyList[qfIdx];
}
const VulkanMemoryType &
getVulkanMemoryType(const VulkanDevice &device,
VulkanMemoryTypeProperty memoryTypeProperty)
{
size_t mtIdx;
const VulkanMemoryTypeList &memoryTypeList =
device.getPhysicalDevice().getMemoryTypeList();
for (mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
{
if ((memoryTypeList[mtIdx].getMemoryTypeProperty() & memoryTypeProperty)
== memoryTypeProperty)
{
break;
}
}
// CHECK_LT(mtIdx, memoryTypeList.size());
return memoryTypeList[mtIdx];
}
bool checkVkSupport()
{
bool result = true;
const VulkanInstance &instance = getVulkanInstance();
const VulkanPhysicalDeviceList &physicalDeviceList =
instance.getPhysicalDeviceList();
if (physicalDeviceList == NULL)
{
std::cout << "physicalDeviceList is null, No GPUs found with "
"Vulkan support !!!\n";
result = false;
}
return result;
}
const VulkanQueueFamilyList &getEmptyVulkanQueueFamilyList()
{
static VulkanQueueFamilyList queueFamilyList;
return queueFamilyList;
}
const VulkanDescriptorSetLayoutList &getEmptyVulkanDescriptorSetLayoutList()
{
static VulkanDescriptorSetLayoutList descriptorSetLayoutList;
return descriptorSetLayoutList;
}
const VulkanQueueFamilyToQueueCountMap &
getDefaultVulkanQueueFamilyToQueueCountMap()
{
static VulkanQueueFamilyToQueueCountMap queueFamilyToQueueCountMap(1);
return queueFamilyToQueueCountMap;
}
const std::vector<VulkanExternalMemoryHandleType>
getSupportedVulkanExternalMemoryHandleTypeList()
{
std::vector<VulkanExternalMemoryHandleType> externalMemoryHandleTypeList;
#if _WIN32
if (IsWindows8OrGreater())
{
externalMemoryHandleTypeList.push_back(
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT);
}
externalMemoryHandleTypeList.push_back(
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT);
#else
externalMemoryHandleTypeList.push_back(
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD);
#endif
return externalMemoryHandleTypeList;
}
const std::vector<VulkanExternalSemaphoreHandleType>
getSupportedVulkanExternalSemaphoreHandleTypeList()
{
std::vector<VulkanExternalSemaphoreHandleType>
externalSemaphoreHandleTypeList;
#if _WIN32
if (IsWindows8OrGreater())
{
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT);
}
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT);
#else
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD);
#endif
return externalSemaphoreHandleTypeList;
}
const std::vector<VulkanFormat> getSupportedVulkanFormatList()
{
std::vector<VulkanFormat> formatList;
formatList.push_back(VULKAN_FORMAT_R8_UINT);
formatList.push_back(VULKAN_FORMAT_R8_SINT);
formatList.push_back(VULKAN_FORMAT_R8G8_UINT);
formatList.push_back(VULKAN_FORMAT_R8G8_SINT);
formatList.push_back(VULKAN_FORMAT_R8G8B8A8_UINT);
formatList.push_back(VULKAN_FORMAT_R8G8B8A8_SINT);
formatList.push_back(VULKAN_FORMAT_R16_UINT);
formatList.push_back(VULKAN_FORMAT_R16_SINT);
formatList.push_back(VULKAN_FORMAT_R16G16_UINT);
formatList.push_back(VULKAN_FORMAT_R16G16_SINT);
formatList.push_back(VULKAN_FORMAT_R16G16B16A16_UINT);
formatList.push_back(VULKAN_FORMAT_R16G16B16A16_SINT);
formatList.push_back(VULKAN_FORMAT_R32_UINT);
formatList.push_back(VULKAN_FORMAT_R32_SINT);
formatList.push_back(VULKAN_FORMAT_R32_SFLOAT);
formatList.push_back(VULKAN_FORMAT_R32G32_UINT);
formatList.push_back(VULKAN_FORMAT_R32G32_SINT);
formatList.push_back(VULKAN_FORMAT_R32G32_SFLOAT);
formatList.push_back(VULKAN_FORMAT_R32G32B32A32_UINT);
formatList.push_back(VULKAN_FORMAT_R32G32B32A32_SINT);
formatList.push_back(VULKAN_FORMAT_R32G32B32A32_SFLOAT);
for (size_t fIdx = 0; fIdx < formatList.size(); fIdx++)
{
switch (formatList[fIdx])
{
case VULKAN_FORMAT_R8_UINT:
case VULKAN_FORMAT_R8_SINT:
case VULKAN_FORMAT_R8G8_UINT:
case VULKAN_FORMAT_R8G8_SINT:
case VULKAN_FORMAT_R8G8B8A8_UINT:
case VULKAN_FORMAT_R8G8B8A8_SINT:
case VULKAN_FORMAT_R16_UINT:
case VULKAN_FORMAT_R16_SINT:
case VULKAN_FORMAT_R16G16_UINT:
case VULKAN_FORMAT_R16G16_SINT:
case VULKAN_FORMAT_R16G16B16A16_UINT:
case VULKAN_FORMAT_R16G16B16A16_SINT:
case VULKAN_FORMAT_R32_UINT:
case VULKAN_FORMAT_R32_SINT:
case VULKAN_FORMAT_R32_SFLOAT:
case VULKAN_FORMAT_R32G32_UINT:
case VULKAN_FORMAT_R32G32_SINT:
case VULKAN_FORMAT_R32G32_SFLOAT:
case VULKAN_FORMAT_R32G32B32A32_UINT:
case VULKAN_FORMAT_R32G32B32A32_SINT:
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: break;
case VULKAN_FORMAT_UNDEFINED:
case VULKAN_FORMAT_R4G4_UNORM_PACK8:
case VULKAN_FORMAT_R4G4B4A4_UNORM_PACK16:
case VULKAN_FORMAT_B4G4R4A4_UNORM_PACK16:
case VULKAN_FORMAT_R5G6B5_UNORM_PACK16:
case VULKAN_FORMAT_B5G6R5_UNORM_PACK16:
case VULKAN_FORMAT_R5G5B5A1_UNORM_PACK16:
case VULKAN_FORMAT_B5G5R5A1_UNORM_PACK16:
case VULKAN_FORMAT_A1R5G5B5_UNORM_PACK16:
case VULKAN_FORMAT_R8_UNORM:
case VULKAN_FORMAT_R8_SNORM:
case VULKAN_FORMAT_R8_USCALED:
case VULKAN_FORMAT_R8_SSCALED:
case VULKAN_FORMAT_R8_SRGB:
case VULKAN_FORMAT_R8G8_SNORM:
case VULKAN_FORMAT_R8G8_UNORM:
case VULKAN_FORMAT_R8G8_USCALED:
case VULKAN_FORMAT_R8G8_SSCALED:
case VULKAN_FORMAT_R8G8_SRGB:
case VULKAN_FORMAT_R8G8B8_UNORM:
case VULKAN_FORMAT_R8G8B8_SNORM:
case VULKAN_FORMAT_R8G8B8_USCALED:
case VULKAN_FORMAT_R8G8B8_SSCALED:
case VULKAN_FORMAT_R8G8B8_UINT:
case VULKAN_FORMAT_R8G8B8_SINT:
case VULKAN_FORMAT_R8G8B8_SRGB:
case VULKAN_FORMAT_B8G8R8_UNORM:
case VULKAN_FORMAT_B8G8R8_SNORM:
case VULKAN_FORMAT_B8G8R8_USCALED:
case VULKAN_FORMAT_B8G8R8_SSCALED:
case VULKAN_FORMAT_B8G8R8_UINT:
case VULKAN_FORMAT_B8G8R8_SINT:
case VULKAN_FORMAT_B8G8R8_SRGB:
case VULKAN_FORMAT_R8G8B8A8_UNORM:
case VULKAN_FORMAT_R8G8B8A8_SNORM:
case VULKAN_FORMAT_R8G8B8A8_USCALED:
case VULKAN_FORMAT_R8G8B8A8_SSCALED:
case VULKAN_FORMAT_R8G8B8A8_SRGB:
case VULKAN_FORMAT_B8G8R8A8_UNORM:
case VULKAN_FORMAT_B8G8R8A8_SNORM:
case VULKAN_FORMAT_B8G8R8A8_USCALED:
case VULKAN_FORMAT_B8G8R8A8_SSCALED:
case VULKAN_FORMAT_B8G8R8A8_UINT:
case VULKAN_FORMAT_B8G8R8A8_SINT:
case VULKAN_FORMAT_B8G8R8A8_SRGB:
case VULKAN_FORMAT_A8B8G8R8_UNORM_PACK32:
case VULKAN_FORMAT_A8B8G8R8_SNORM_PACK32:
case VULKAN_FORMAT_A8B8G8R8_USCALED_PACK32:
case VULKAN_FORMAT_A8B8G8R8_SSCALED_PACK32:
case VULKAN_FORMAT_A8B8G8R8_UINT_PACK32:
case VULKAN_FORMAT_A8B8G8R8_SINT_PACK32:
case VULKAN_FORMAT_A8B8G8R8_SRGB_PACK32:
case VULKAN_FORMAT_A2R10G10B10_UNORM_PACK32:
case VULKAN_FORMAT_A2R10G10B10_SNORM_PACK32:
case VULKAN_FORMAT_A2R10G10B10_USCALED_PACK32:
case VULKAN_FORMAT_A2R10G10B10_SSCALED_PACK32:
case VULKAN_FORMAT_A2R10G10B10_UINT_PACK32:
case VULKAN_FORMAT_A2R10G10B10_SINT_PACK32:
case VULKAN_FORMAT_A2B10G10R10_UNORM_PACK32:
case VULKAN_FORMAT_A2B10G10R10_SNORM_PACK32:
case VULKAN_FORMAT_A2B10G10R10_USCALED_PACK32:
case VULKAN_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VULKAN_FORMAT_A2B10G10R10_UINT_PACK32:
case VULKAN_FORMAT_A2B10G10R10_SINT_PACK32:
case VULKAN_FORMAT_R16_UNORM:
case VULKAN_FORMAT_R16_SNORM:
case VULKAN_FORMAT_R16_USCALED:
case VULKAN_FORMAT_R16_SSCALED:
case VULKAN_FORMAT_R16_SFLOAT:
case VULKAN_FORMAT_R16G16_UNORM:
case VULKAN_FORMAT_R16G16_SNORM:
case VULKAN_FORMAT_R16G16_USCALED:
case VULKAN_FORMAT_R16G16_SSCALED:
case VULKAN_FORMAT_R16G16_SFLOAT:
case VULKAN_FORMAT_R16G16B16_UNORM:
case VULKAN_FORMAT_R16G16B16_SNORM:
case VULKAN_FORMAT_R16G16B16_USCALED:
case VULKAN_FORMAT_R16G16B16_SSCALED:
case VULKAN_FORMAT_R16G16B16_UINT:
case VULKAN_FORMAT_R16G16B16_SINT:
case VULKAN_FORMAT_R16G16B16_SFLOAT:
case VULKAN_FORMAT_R16G16B16A16_UNORM:
case VULKAN_FORMAT_R16G16B16A16_SNORM:
case VULKAN_FORMAT_R16G16B16A16_USCALED:
case VULKAN_FORMAT_R16G16B16A16_SSCALED:
case VULKAN_FORMAT_R16G16B16A16_SFLOAT:
case VULKAN_FORMAT_R32G32B32_UINT:
case VULKAN_FORMAT_R32G32B32_SINT:
case VULKAN_FORMAT_R32G32B32_SFLOAT:
case VULKAN_FORMAT_R64_UINT:
case VULKAN_FORMAT_R64_SINT:
case VULKAN_FORMAT_R64_SFLOAT:
case VULKAN_FORMAT_R64G64_UINT:
case VULKAN_FORMAT_R64G64_SINT:
case VULKAN_FORMAT_R64G64_SFLOAT:
case VULKAN_FORMAT_R64G64B64_UINT:
case VULKAN_FORMAT_R64G64B64_SINT:
case VULKAN_FORMAT_R64G64B64_SFLOAT:
case VULKAN_FORMAT_R64G64B64A64_UINT:
case VULKAN_FORMAT_R64G64B64A64_SINT:
case VULKAN_FORMAT_R64G64B64A64_SFLOAT:
case VULKAN_FORMAT_B10G11R11_UFLOAT_PACK32:
case VULKAN_FORMAT_E5B9G9R9_UFLOAT_PACK32:
case VULKAN_FORMAT_D16_UNORM:
case VULKAN_FORMAT_X8_D24_UNORM_PACK32:
case VULKAN_FORMAT_D32_SFLOAT:
case VULKAN_FORMAT_S8_UINT:
case VULKAN_FORMAT_D16_UNORM_S8_UINT:
case VULKAN_FORMAT_D24_UNORM_S8_UINT:
case VULKAN_FORMAT_D32_SFLOAT_S8_UINT:
case VULKAN_FORMAT_BC1_RGB_UNORM_BLOCK:
case VULKAN_FORMAT_BC1_RGB_SRGB_BLOCK:
case VULKAN_FORMAT_BC1_RGBA_UNORM_BLOCK:
case VULKAN_FORMAT_BC1_RGBA_SRGB_BLOCK:
case VULKAN_FORMAT_BC2_UNORM_BLOCK:
case VULKAN_FORMAT_BC2_SRGB_BLOCK:
case VULKAN_FORMAT_BC3_UNORM_BLOCK:
case VULKAN_FORMAT_BC3_SRGB_BLOCK:
case VULKAN_FORMAT_BC4_UNORM_BLOCK:
case VULKAN_FORMAT_BC4_SNORM_BLOCK:
case VULKAN_FORMAT_BC5_UNORM_BLOCK:
case VULKAN_FORMAT_BC5_SNORM_BLOCK:
case VULKAN_FORMAT_BC6H_UFLOAT_BLOCK:
case VULKAN_FORMAT_BC6H_SFLOAT_BLOCK:
case VULKAN_FORMAT_BC7_UNORM_BLOCK:
case VULKAN_FORMAT_BC7_SRGB_BLOCK:
case VULKAN_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
case VULKAN_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
case VULKAN_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
case VULKAN_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
case VULKAN_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
case VULKAN_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
case VULKAN_FORMAT_EAC_R11_UNORM_BLOCK:
case VULKAN_FORMAT_EAC_R11_SNORM_BLOCK:
case VULKAN_FORMAT_EAC_R11G11_UNORM_BLOCK:
case VULKAN_FORMAT_EAC_R11G11_SNORM_BLOCK:
case VULKAN_FORMAT_ASTC_4x4_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_4x4_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_5x4_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_5x4_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_5x5_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_5x5_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_6x5_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_6x5_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_6x6_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_6x6_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_8x5_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_8x5_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_8x6_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_8x6_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_8x8_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_8x8_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_10x5_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_10x5_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_10x6_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_10x6_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_10x8_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_10x8_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_10x10_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_10x10_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_12x10_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_12x10_SRGB_BLOCK:
case VULKAN_FORMAT_ASTC_12x12_UNORM_BLOCK:
case VULKAN_FORMAT_ASTC_12x12_SRGB_BLOCK:
ASSERT(0);
std::cout << "Unsupport texture format";
}
}
return formatList;
}
uint32_t getVulkanFormatElementSize(VulkanFormat format)
{
switch (format)
{
case VULKAN_FORMAT_R8_UINT: return uint32_t(1);
case VULKAN_FORMAT_R8_SINT: return uint32_t(1);
case VULKAN_FORMAT_R8G8_UINT: return uint32_t(2);
case VULKAN_FORMAT_R8G8_SINT: return uint32_t(2);
case VULKAN_FORMAT_R8G8B8A8_UINT: return uint32_t(4);
case VULKAN_FORMAT_R8G8B8A8_SINT: return uint32_t(4);
case VULKAN_FORMAT_R16_UINT: return uint32_t(2);
case VULKAN_FORMAT_R16_SINT: return uint32_t(2);
case VULKAN_FORMAT_R16G16_UINT: return uint32_t(4);
case VULKAN_FORMAT_R16G16_SINT: return uint32_t(4);
case VULKAN_FORMAT_R16G16B16A16_UINT: return uint32_t(8);
case VULKAN_FORMAT_R16G16B16A16_SINT: return uint32_t(8);
case VULKAN_FORMAT_R32_UINT: return uint32_t(4);
case VULKAN_FORMAT_R32_SINT: return uint32_t(4);
case VULKAN_FORMAT_R32_SFLOAT: return uint32_t(4);
case VULKAN_FORMAT_R32G32_UINT: return uint32_t(8);
case VULKAN_FORMAT_R32G32_SINT: return uint32_t(8);
case VULKAN_FORMAT_R32G32_SFLOAT: return uint32_t(8);
case VULKAN_FORMAT_R32G32B32A32_UINT: return uint32_t(16);
case VULKAN_FORMAT_R32G32B32A32_SINT: return uint32_t(16);
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return uint32_t(16);
default: ASSERT(0); std::cout << "Unknown format";
}
return uint32_t(0);
}
const char *getVulkanFormatGLSLFormat(VulkanFormat format)
{
switch (format)
{
case VULKAN_FORMAT_R8_UINT: return "r8ui";
case VULKAN_FORMAT_R8_SINT: return "r8i";
case VULKAN_FORMAT_R8G8_UINT: return "rg8ui";
case VULKAN_FORMAT_R8G8_SINT: return "rg8i";
case VULKAN_FORMAT_R8G8B8A8_UINT: return "rgba8ui";
case VULKAN_FORMAT_R8G8B8A8_SINT: return "rgba8i";
case VULKAN_FORMAT_R16_UINT: return "r16ui";
case VULKAN_FORMAT_R16_SINT: return "r16i";
case VULKAN_FORMAT_R16G16_UINT: return "rg16ui";
case VULKAN_FORMAT_R16G16_SINT: return "rg16i";
case VULKAN_FORMAT_R16G16B16A16_UINT: return "rgba16ui";
case VULKAN_FORMAT_R16G16B16A16_SINT: return "rgba16i";
case VULKAN_FORMAT_R32_UINT: return "r32ui";
case VULKAN_FORMAT_R32_SINT: return "r32i";
case VULKAN_FORMAT_R32_SFLOAT: return "r32f";
case VULKAN_FORMAT_R32G32_UINT: return "rg32ui";
case VULKAN_FORMAT_R32G32_SINT: return "rg32i";
case VULKAN_FORMAT_R32G32_SFLOAT: return "rg32f";
case VULKAN_FORMAT_R32G32B32A32_UINT: return "rgba32ui";
case VULKAN_FORMAT_R32G32B32A32_SINT: return "rgba32i";
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return "rgba32f";
default: ASSERT(0); std::cout << "Unknown format";
}
return (const char *)size_t(0);
}
const char *getVulkanFormatGLSLTypePrefix(VulkanFormat format)
{
switch (format)
{
case VULKAN_FORMAT_R8_UINT:
case VULKAN_FORMAT_R8G8_UINT:
case VULKAN_FORMAT_R8G8B8A8_UINT:
case VULKAN_FORMAT_R16_UINT:
case VULKAN_FORMAT_R16G16_UINT:
case VULKAN_FORMAT_R16G16B16A16_UINT:
case VULKAN_FORMAT_R32_UINT:
case VULKAN_FORMAT_R32G32_UINT:
case VULKAN_FORMAT_R32G32B32A32_UINT: return "u";
case VULKAN_FORMAT_R8_SINT:
case VULKAN_FORMAT_R8G8_SINT:
case VULKAN_FORMAT_R8G8B8A8_SINT:
case VULKAN_FORMAT_R16_SINT:
case VULKAN_FORMAT_R16G16_SINT:
case VULKAN_FORMAT_R16G16B16A16_SINT:
case VULKAN_FORMAT_R32_SINT:
case VULKAN_FORMAT_R32G32_SINT:
case VULKAN_FORMAT_R32G32B32A32_SINT: return "i";
case VULKAN_FORMAT_R32_SFLOAT:
case VULKAN_FORMAT_R32G32_SFLOAT:
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return "";
default: ASSERT(0); std::cout << "Unknown format";
}
return "";
}
std::string prepareVulkanShader(
std::string shaderCode,
const std::map<std::string, std::string> &patternToSubstituteMap)
{
for (std::map<std::string, std::string>::const_iterator psIt =
patternToSubstituteMap.begin();
psIt != patternToSubstituteMap.end(); ++psIt)
{
std::string::size_type pos = 0u;
while ((pos = shaderCode.find(psIt->first, pos)) != std::string::npos)
{
shaderCode.replace(pos, psIt->first.length(), psIt->second);
pos += psIt->second.length();
}
}
return shaderCode;
}
std::ostream &operator<<(std::ostream &os,
VulkanMemoryTypeProperty memoryTypeProperty)
{
switch (memoryTypeProperty)
{
case VULKAN_MEMORY_TYPE_PROPERTY_NONE: return os << "None";
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL:
return os << "Device local";
case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_COHERENT:
return os << "Host visible and coherent";
case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED:
return os << "Host visible and cached";
case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED_COHERENT:
return os << "Host visible, cached and coherent";
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_COHERENT:
return os << "Device local, Host visible and coherent";
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED:
return os << "Device local, Host visible and cached";
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED_COHERENT:
return os << "Device local, Host visible, cached and coherent";
}
return os;
}
std::ostream &
operator<<(std::ostream &os,
VulkanExternalMemoryHandleType externalMemoryHandleType)
{
switch (externalMemoryHandleType)
{
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: return os << "None";
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
return os << "Opaque file descriptor";
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
return os << "Opaque NT handle";
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
return os << "Opaque D3DKMT handle";
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
return os << "Opaque NT and D3DKMT handle";
}
return os;
}
std::ostream &
operator<<(std::ostream &os,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType)
{
switch (externalSemaphoreHandleType)
{
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE: return os << "None";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
return os << "Opaque file descriptor";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
return os << "Opaque NT handle";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
return os << "Opaque D3DKMT handle";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
return os << "Opaque NT and D3DKMT handle";
}
return os;
}
std::ostream &operator<<(std::ostream &os, VulkanFormat format)
{
switch (format)
{
case VULKAN_FORMAT_R8_UINT: return os << "R8_UINT";
case VULKAN_FORMAT_R8_SINT: return os << "R8_SINT";
case VULKAN_FORMAT_R8G8_UINT: return os << "R8G8_UINT";
case VULKAN_FORMAT_R8G8_SINT: return os << "R8G8_SINT";
case VULKAN_FORMAT_R8G8B8A8_UINT: return os << "R8G8B8A8_UINT";
case VULKAN_FORMAT_R8G8B8A8_SINT: return os << "R8G8B8A8_SINT";
case VULKAN_FORMAT_R16_UINT: return os << "R16_UINT";
case VULKAN_FORMAT_R16_SINT: return os << "R16_SINT";
case VULKAN_FORMAT_R16G16_UINT: return os << "R16G16_UINT";
case VULKAN_FORMAT_R16G16_SINT: return os << "R16G16_SINT";
case VULKAN_FORMAT_R16G16B16A16_UINT: return os << "R16G16B16A16_UINT";
case VULKAN_FORMAT_R16G16B16A16_SINT: return os << "R16G16B16A16_SINT";
case VULKAN_FORMAT_R32_UINT: return os << "R32_UINT";
case VULKAN_FORMAT_R32_SINT: return os << "R32_SINT";
case VULKAN_FORMAT_R32_SFLOAT: return os << "R32_SFLOAT";
case VULKAN_FORMAT_R32G32_UINT: return os << "R32G32_UINT";
case VULKAN_FORMAT_R32G32_SINT: return os << "R32G32_SINT";
case VULKAN_FORMAT_R32G32_SFLOAT: return os << "R32G32_SFLOAT";
case VULKAN_FORMAT_R32G32B32A32_UINT: return os << "R32G32B32A32_UINT";
case VULKAN_FORMAT_R32G32B32A32_SINT: return os << "R32G32B32A32_SINT";
case VULKAN_FORMAT_R32G32B32A32_SFLOAT:
return os << "R32G32B32A32_SFLOAT";
break;
default: ASSERT(0); std::cout << "Unknown format";
}
return os;
}

69
test_conformance/vulkan/vulkan_interop_common/vulkan_utility.hpp Normal file
View File

@@ -0,0 +1,69 @@
//
// 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_utility_hpp_
#define _vulkan_utility_hpp_
#include "vulkan_wrapper_types.hpp"
#include <vector>
#include <ostream>
#include <string.h>
#include <map>
#include "../../../test_common/harness/testHarness.h"
#define STRING_(str) #str
#define STRING(str) STRING_(str)
#define ROUND_UP(n, multiple) \
(((n) + (multiple)-1) - ((((n) + (multiple)-1)) % (multiple)))
const VulkanInstance& getVulkanInstance();
const VulkanPhysicalDevice& getVulkanPhysicalDevice();
const VulkanQueueFamily&
getVulkanQueueFamily(uint32_t queueFlags = VULKAN_QUEUE_FLAG_MASK_ALL);
const VulkanMemoryType&
getVulkanMemoryType(const VulkanDevice& device,
VulkanMemoryTypeProperty memoryTypeProperty);
bool checkVkSupport();
const VulkanQueueFamilyList& getEmptyVulkanQueueFamilyList();
const VulkanDescriptorSetLayoutList& getEmptyVulkanDescriptorSetLayoutList();
const VulkanQueueFamilyToQueueCountMap&
getDefaultVulkanQueueFamilyToQueueCountMap();
const std::vector<VulkanExternalMemoryHandleType>
getSupportedVulkanExternalMemoryHandleTypeList();
const std::vector<VulkanExternalSemaphoreHandleType>
getSupportedVulkanExternalSemaphoreHandleTypeList();
const std::vector<VulkanFormat> getSupportedVulkanFormatList();
uint32_t getVulkanFormatElementSize(VulkanFormat format);
const char* getVulkanFormatGLSLFormat(VulkanFormat format);
const char* getVulkanFormatGLSLTypePrefix(VulkanFormat format);
std::string prepareVulkanShader(
std::string shaderCode,
const std::map<std::string, std::string>& patternToSubstituteMap);
std::ostream& operator<<(std::ostream& os,
VulkanMemoryTypeProperty memoryTypeProperty);
std::ostream&
operator<<(std::ostream& os,
VulkanExternalMemoryHandleType externalMemoryHandleType);
std::ostream&
operator<<(std::ostream& os,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType);
std::ostream& operator<<(std::ostream& os, VulkanFormat format);
#endif // _vulkan_utility_hpp_

2075
test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

579
test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper.hpp Normal file
View File

@@ -0,0 +1,579 @@
//
// 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_hpp_
#define _vulkan_wrapper_hpp_
#include <vulkan/vulkan.h>
#include "vulkan_wrapper_types.hpp"
#include "vulkan_list_map.hpp"
#include "vulkan_api_list.hpp"
class VulkanInstance {
friend const VulkanInstance &getVulkanInstance();
protected:
VkInstance m_vkInstance;
VulkanPhysicalDeviceList m_physicalDeviceList;
VulkanInstance();
VulkanInstance(const VulkanInstance &);
virtual ~VulkanInstance();
public:
const VulkanPhysicalDeviceList &getPhysicalDeviceList() const;
operator VkInstance() const;
};
class VulkanPhysicalDevice {
friend class VulkanInstance;
protected:
VkPhysicalDevice m_vkPhysicalDevice;
VkPhysicalDeviceProperties m_vkPhysicalDeviceProperties;
uint8_t m_vkDeviceUUID[VK_UUID_SIZE];
uint8_t m_vkDeviceLUID[VK_LUID_SIZE];
uint32_t m_vkDeviceNodeMask;
VkPhysicalDeviceFeatures m_vkPhysicalDeviceFeatures;
VkPhysicalDeviceMemoryProperties m_vkPhysicalDeviceMemoryProperties;
VulkanQueueFamilyList m_queueFamilyList;
VulkanMemoryHeapList m_memoryHeapList;
VulkanMemoryTypeList m_memoryTypeList;
VulkanPhysicalDevice(const VulkanPhysicalDevice &physicalDevice);
VulkanPhysicalDevice(VkPhysicalDevice vkPhysicalDevice);
virtual ~VulkanPhysicalDevice();
public:
const VulkanQueueFamilyList &getQueueFamilyList() const;
const VulkanMemoryHeapList &getMemoryHeapList() const;
const VulkanMemoryTypeList &getMemoryTypeList() const;
const uint8_t *getUUID() const;
const uint8_t *getLUID() const;
uint32_t getNodeMask() const;
operator VkPhysicalDevice() const;
};
class VulkanMemoryHeap {
friend class VulkanPhysicalDevice;
protected:
uint32_t m_memoryHeapIndex;
uint64_t m_size;
VulkanMemoryHeapFlag m_memoryHeapFlag;
VulkanMemoryHeap(const VulkanMemoryHeap &memoryHeap);
VulkanMemoryHeap(uint32_t m_memoryHeapIndex, uint64_t m_size,
VulkanMemoryHeapFlag m_memoryHeapFlag);
virtual ~VulkanMemoryHeap();
public:
uint64_t getSize() const;
VulkanMemoryHeapFlag getMemoryHeapFlag() const;
operator uint32_t() const;
};
class VulkanMemoryType {
friend class VulkanPhysicalDevice;
protected:
uint32_t m_memoryTypeIndex;
const VulkanMemoryTypeProperty m_memoryTypeProperty;
const VulkanMemoryHeap &m_memoryHeap;
VulkanMemoryType(const VulkanMemoryType &memoryType);
VulkanMemoryType(uint32_t memoryTypeIndex,
VulkanMemoryTypeProperty memoryTypeProperty,
const VulkanMemoryHeap &memoryHeap);
virtual ~VulkanMemoryType();
public:
VulkanMemoryTypeProperty getMemoryTypeProperty() const;
const VulkanMemoryHeap &getMemoryHeap() const;
operator uint32_t() const;
};
class VulkanQueueFamily {
friend class VulkanPhysicalDevice;
protected:
uint32_t m_queueFamilyIndex;
VkQueueFamilyProperties m_vkQueueFamilyProperties;
VulkanQueueFamily(const VulkanQueueFamily &queueFamily);
VulkanQueueFamily(uint32_t queueFamilyIndex,
VkQueueFamilyProperties vkQueueFamilyProperties);
virtual ~VulkanQueueFamily();
public:
uint32_t getQueueFlags() const;
uint32_t getQueueCount() const;
operator uint32_t() const;
};
class VulkanDevice {
protected:
const VulkanPhysicalDevice &m_physicalDevice;
VkDevice m_vkDevice;
VulkanQueueFamilyToQueueListMap m_queueFamilyIndexToQueueListMap;
VulkanDevice(const VulkanDevice &device);
public:
VulkanDevice(
const VulkanPhysicalDevice &physicalDevice = getVulkanPhysicalDevice(),
const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap =
getDefaultVulkanQueueFamilyToQueueCountMap());
virtual ~VulkanDevice();
const VulkanPhysicalDevice &getPhysicalDevice() const;
VulkanQueue &
getQueue(const VulkanQueueFamily &queueFamily = getVulkanQueueFamily(),
uint32_t queueIndex = 0);
operator VkDevice() const;
};
class VulkanQueue {
friend class VulkanDevice;
protected:
VkQueue m_vkQueue;
VulkanQueue(VkQueue vkQueue);
VulkanQueue(const VulkanQueue &queue);
virtual ~VulkanQueue();
public:
const VulkanQueueFamily &getQueueFamily();
void submit(const VulkanSemaphoreList &waitSemaphoreList,
const VulkanCommandBufferList &commandBufferList,
const VulkanSemaphoreList &signalSemaphoreList);
void submit(const VulkanSemaphore &waitSemaphore,
const VulkanCommandBuffer &commandBuffer,
const VulkanSemaphore &signalSemaphore);
void submit(const VulkanCommandBuffer &commandBuffer,
const VulkanSemaphore &signalSemaphore);
void submit(const VulkanCommandBuffer &commandBuffer);
void waitIdle();
operator VkQueue() const;
};
class VulkanDescriptorSetLayoutBinding {
protected:
VkDescriptorSetLayoutBinding m_vkDescriptorSetLayoutBinding;
VulkanDescriptorSetLayoutBinding(
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
public:
VulkanDescriptorSetLayoutBinding(
uint32_t binding, VulkanDescriptorType descriptorType,
uint32_t descriptorCount = 1,
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
virtual ~VulkanDescriptorSetLayoutBinding();
operator VkDescriptorSetLayoutBinding() const;
};
class VulkanDescriptorSetLayout {
protected:
const VulkanDevice &m_device;
VkDescriptorSetLayout m_vkDescriptorSetLayout;
VulkanDescriptorSetLayout(
const VulkanDescriptorSetLayout &descriptorSetLayout);
void
VulkanDescriptorSetLayoutCommon(const VulkanDescriptorSetLayoutBindingList
&descriptorSetLayoutBindingList);
public:
VulkanDescriptorSetLayout(
const VulkanDevice &device,
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
VulkanDescriptorSetLayout(
const VulkanDevice &device,
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding0,
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding1);
VulkanDescriptorSetLayout(const VulkanDevice &device,
const VulkanDescriptorSetLayoutBindingList
&descriptorSetLayoutBindingList);
virtual ~VulkanDescriptorSetLayout();
operator VkDescriptorSetLayout() const;
};
class VulkanPipelineLayout {
protected:
const VulkanDevice &m_device;
VkPipelineLayout m_vkPipelineLayout;
VulkanPipelineLayout(const VulkanPipelineLayout &pipelineLayout);
void VulkanPipelineLayoutCommon(
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList);
public:
VulkanPipelineLayout(const VulkanDevice &device,
const VulkanDescriptorSetLayout &descriptorSetLayout);
VulkanPipelineLayout(
const VulkanDevice &device,
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList =
getEmptyVulkanDescriptorSetLayoutList());
virtual ~VulkanPipelineLayout();
operator VkPipelineLayout() const;
};
class VulkanShaderModule {
protected:
const VulkanDevice &m_device;
VkShaderModule m_vkShaderModule;
VulkanShaderModule(const VulkanShaderModule &shaderModule);
public:
VulkanShaderModule(const VulkanDevice &device, const std::string &code);
virtual ~VulkanShaderModule();
operator VkShaderModule() const;
};
class VulkanPipeline {
protected:
const VulkanDevice &m_device;
VkPipeline m_vkPipeline;
VulkanPipeline(const VulkanPipeline &pipeline);
public:
VulkanPipeline(const VulkanDevice &device);
virtual ~VulkanPipeline();
virtual VulkanPipelineBindPoint getPipelineBindPoint() const = 0;
operator VkPipeline() const;
};
class VulkanComputePipeline : public VulkanPipeline {
protected:
VulkanComputePipeline(const VulkanComputePipeline &computePipeline);
public:
VulkanComputePipeline(const VulkanDevice &device,
const VulkanPipelineLayout &pipelineLayout,
const VulkanShaderModule &shaderModule,
const std::string &entryFuncName = "main");
virtual ~VulkanComputePipeline();
VulkanPipelineBindPoint getPipelineBindPoint() const;
};
class VulkanDescriptorPool {
protected:
const VulkanDevice &m_device;
VkDescriptorPool m_vkDescriptorPool;
VulkanDescriptorPool(const VulkanDescriptorPool &descriptorPool);
void VulkanDescriptorPoolCommon(const VulkanDescriptorSetLayoutBindingList
&descriptorSetLayoutBindingList);
public:
VulkanDescriptorPool(
const VulkanDevice &device,
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
VulkanDescriptorPool(
const VulkanDevice &device,
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding0,
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding1);
VulkanDescriptorPool(const VulkanDevice &device,
const VulkanDescriptorSetLayoutBindingList
&descriptorSetLayoutBindingList);
virtual ~VulkanDescriptorPool();
operator VkDescriptorPool() const;
};
class VulkanDescriptorSet {
protected:
const VulkanDevice &m_device;
const VulkanDescriptorPool &m_descriptorPool;
VkDescriptorSet m_vkDescriptorSet;
VulkanDescriptorSet(const VulkanDescriptorSet &descriptorSet);
public:
VulkanDescriptorSet(const VulkanDevice &device,
const VulkanDescriptorPool &descriptorPool,
const VulkanDescriptorSetLayout &descriptorSetLayout);
virtual ~VulkanDescriptorSet();
void update(uint32_t binding, const VulkanBuffer &buffer);
void update(uint32_t binding, const VulkanImageView &imageView);
operator VkDescriptorSet() const;
};
class VulkanOffset3D {
protected:
VkOffset3D m_vkOffset3D;
public:
VulkanOffset3D(const VulkanOffset3D &extent3D);
VulkanOffset3D(uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);
virtual ~VulkanOffset3D();
uint32_t getX() const;
uint32_t getY() const;
uint32_t getZ() const;
operator VkOffset3D() const;
};
class VulkanExtent3D {
protected:
VkExtent3D m_vkExtent3D;
public:
VulkanExtent3D(const VulkanExtent3D &extent3D);
VulkanExtent3D(uint32_t width, uint32_t height = 1, uint32_t depth = 1);
virtual ~VulkanExtent3D();
uint32_t getWidth() const;
uint32_t getHeight() const;
uint32_t getDepth() const;
operator VkExtent3D() const;
};
class VulkanCommandPool {
protected:
const VulkanDevice &m_device;
VkCommandPool m_vkCommandPool;
VulkanCommandPool(const VulkanCommandPool &commandPool);
public:
VulkanCommandPool(
const VulkanDevice &device,
const VulkanQueueFamily &queueFamily = getVulkanQueueFamily());
virtual ~VulkanCommandPool();
operator VkCommandPool() const;
};
class VulkanCommandBuffer {
protected:
const VulkanDevice &m_device;
const VulkanCommandPool &m_commandPool;
VkCommandBuffer m_vkCommandBuffer;
VulkanCommandBuffer(const VulkanCommandBuffer &commandBuffer);
public:
VulkanCommandBuffer(const VulkanDevice &device,
const VulkanCommandPool &commandPool);
virtual ~VulkanCommandBuffer();
void begin();
void bindPipeline(const VulkanPipeline &pipeline);
void bindDescriptorSets(const VulkanPipeline &pipeline,
const VulkanPipelineLayout &pipelineLayout,
const VulkanDescriptorSet &descriptorSet);
void pipelineBarrier(const VulkanImage2DList &image2DList,
VulkanImageLayout oldImageLayout,
VulkanImageLayout newImageLayout);
void dispatch(uint32_t groupCountX, uint32_t groupCountY,
uint32_t groupCountZ);
void fillBuffer(const VulkanBuffer &buffer, uint32_t data,
uint64_t offset = 0, uint64_t size = VK_WHOLE_SIZE);
void updateBuffer(const VulkanBuffer &buffer, void *pdata,
uint64_t offset = 0, uint64_t size = VK_WHOLE_SIZE);
void copyBufferToImage(const VulkanBuffer &buffer, const VulkanImage &image,
VulkanImageLayout imageLayout =
VULKAN_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
void copyBufferToImage(const VulkanBuffer &buffer, const VulkanImage &image,
uint64_t bufferOffset = 0, uint32_t mipLevel = 0,
uint32_t baseArrayLayer = 0, uint32_t layerCount = 1,
VulkanOffset3D offset3D = VulkanOffset3D(0, 0, 0),
VulkanExtent3D extent3D = VulkanExtent3D(0, 0, 0));
void copyImageToBuffer(const VulkanImage &image, const VulkanBuffer &buffer,
uint64_t bufferOffset = 0, uint32_t mipLevel = 0,
uint32_t baseArrayLayer = 0, uint32_t layerCount = 1,
VulkanOffset3D offset3D = VulkanOffset3D(0, 0, 0),
VulkanExtent3D extent3D = VulkanExtent3D(0, 0, 0));
void end();
operator VkCommandBuffer() const;
};
class VulkanBuffer {
protected:
const VulkanDevice &m_device;
VkBuffer m_vkBuffer;
uint64_t m_size;
uint64_t m_alignment;
VulkanMemoryTypeList m_memoryTypeList;
VulkanBuffer(const VulkanBuffer &buffer);
public:
VulkanBuffer(const VulkanDevice &device, uint64_t size,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanBufferUsage bufferUsage =
VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST,
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE,
const VulkanQueueFamilyList &queueFamilyList =
getEmptyVulkanQueueFamilyList());
virtual ~VulkanBuffer();
uint64_t getSize() const;
uint64_t getAlignment() const;
const VulkanMemoryTypeList &getMemoryTypeList() const;
operator VkBuffer() const;
};
class VulkanImage {
protected:
const VulkanDevice &m_device;
const VulkanImageType m_imageType;
const VulkanExtent3D m_extent3D;
const VulkanFormat m_format;
const uint32_t m_numMipLevels;
const uint32_t m_numLayers;
VkImage m_vkImage;
uint64_t m_size;
uint64_t m_alignment;
VulkanMemoryTypeList m_memoryTypeList;
VkImageCreateInfo VulkanImageCreateInfo;
VulkanImage(const VulkanImage &image);
public:
VulkanImage(
const VulkanDevice &device, VulkanImageType imageType,
VulkanFormat format, const VulkanExtent3D &extent3D,
uint32_t numMipLevels = 1, uint32_t arrayLayers = 1,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlags = VULKAN_IMAGE_CREATE_FLAG_NONE,
VulkanImageTiling imageTiling = VULKAN_IMAGE_TILING_OPTIMAL,
VulkanImageUsage imageUsage =
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
virtual ~VulkanImage();
virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
VulkanFormat getFormat() const;
uint32_t getNumMipLevels() const;
uint32_t getNumLayers() const;
uint64_t getSize() const;
uint64_t getAlignment() const;
const VulkanMemoryTypeList &getMemoryTypeList() const;
VkImageCreateInfo getVkImageCreateInfo() const;
operator VkImage() const;
};
class VulkanImage2D : public VulkanImage {
protected:
VkImageView m_vkImageView;
VulkanImage2D(const VulkanImage2D &image2D);
public:
VulkanImage2D(
const VulkanDevice &device, VulkanFormat format, uint32_t width,
uint32_t height, uint32_t numMipLevels = 1,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
VulkanImageUsage imageUsage =
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
virtual ~VulkanImage2D();
virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
};
class VulkanImageView {
protected:
const VulkanDevice &m_device;
VkImageView m_vkImageView;
VulkanImageView(const VulkanImageView &imageView);
public:
VulkanImageView(const VulkanDevice &device, const VulkanImage &image,
VulkanImageViewType imageViewType,
uint32_t baseMipLevel = 0,
uint32_t mipLevelCount = VULKAN_REMAINING_MIP_LEVELS,
uint32_t baseArrayLayer = 0,
uint32_t layerCount = VULKAN_REMAINING_ARRAY_LAYERS);
virtual ~VulkanImageView();
operator VkImageView() const;
};
class VulkanDeviceMemory {
protected:
const VulkanDevice &m_device;
VkDeviceMemory m_vkDeviceMemory;
uint64_t m_size;
bool m_isDedicated;
VulkanDeviceMemory(const VulkanDeviceMemory &deviceMemory);
public:
VulkanDeviceMemory(const VulkanDevice &device, uint64_t size,
const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
const void *name = NULL);
VulkanDeviceMemory(const VulkanDevice &device, const VulkanImage &image,
const VulkanMemoryType &memoryType,
VulkanExternalMemoryHandleType externalMemoryHandleType =
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
const void *name = NULL);
virtual ~VulkanDeviceMemory();
uint64_t getSize() const;
#ifdef _WIN32
HANDLE
getHandle(VulkanExternalMemoryHandleType externalMemoryHandleType) const;
#else
int
getHandle(VulkanExternalMemoryHandleType externalMemoryHandleType) const;
#endif
bool isDedicated() const;
void *map(size_t offset = 0, size_t size = VK_WHOLE_SIZE);
void unmap();
void bindBuffer(const VulkanBuffer &buffer, uint64_t offset = 0);
void bindImage(const VulkanImage &image, uint64_t offset = 0);
operator VkDeviceMemory() const;
};
class VulkanSemaphore {
friend class VulkanQueue;
protected:
const VulkanDevice &m_device;
VkSemaphore m_vkSemaphore;
const std::wstring m_name;
VulkanSemaphore(const VulkanSemaphore &semaphore);
public:
VulkanSemaphore(
const VulkanDevice &device,
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType =
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE,
const std::wstring name = L"");
virtual ~VulkanSemaphore();
#ifdef _WIN32
HANDLE getHandle(
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType) const;
#else
int getHandle(
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType) const;
#endif
const std::wstring &getName() const;
operator VkSemaphore() const;
};
#define VK_FUNC_DECL(name) extern "C" PFN_##name _##name;
VK_FUNC_LIST
#if defined(_WIN32) || defined(_WIN64)
VK_WINDOWS_FUNC_LIST
#endif
#undef VK_FUNC_DECL
#endif // _vulkan_wrapper_hpp_

463
test_conformance/vulkan/vulkan_interop_common/vulkan_wrapper_types.hpp Normal file
View File

@@ -0,0 +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 <vulkan/vulkan.h>
#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_