ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-25 16:29:03 +00:00
Code Packages Projects Releases Wiki Activity

Refactor external semaphore scaffolding (#2300)

Browse Source 
Remove the `CREATE_OPENCL_SEMAPHORE` macro and use derived class
instantiations of the `clExternalSemaphore` class, rather than base
pointers to derived class objects.

Remove the default argument for `queryParamName` in
`check_external_semaphore_handle_type()`.

Move `check_external_semaphore_handle_type()` checks to constructors of
`clExternalImportableSemaphore` and `clExternalExportableSemaphore`,
rather than manually making the check before creating an external
semaphore.

---------

Signed-off-by: Gorazd Sumkovski <gorazd.sumkovski@arm.com>
Co-authored-by: Kévin Petit <kpet@free.fr>
Co-authored-by: Kevin Petit <kevin.petit@arm.com>
This commit is contained in:
gorazd-sumkovski-arm
2025-04-16 04:41:38 +01:00
committed by GitHub
parent 4ce3d8968a
commit 33846e6673
6 changed files with 148 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp
View File

@@ -529,8 +529,8 @@ cl_int check_external_memory_handle_type(
return CL_INVALID_VALUE; return CL_INVALID_VALUE;
} }
cl_int check_external_semaphore_handle_type( void check_external_semaphore_handle_type(
cl_device_id deviceID, cl_device_id device,
cl_external_semaphore_handle_type_khr requiredHandleType, cl_external_semaphore_handle_type_khr requiredHandleType,
cl_device_info queryParamName) cl_device_info queryParamName)
{ {
@@ -540,8 +540,8 @@ cl_int check_external_semaphore_handle_type(
cl_int errNum = CL_SUCCESS; cl_int errNum = CL_SUCCESS;
errNum = errNum =
clGetDeviceInfo(deviceID, queryParamName, 0, NULL, &handle_type_size); clGetDeviceInfo(device, queryParamName, 0, NULL, &handle_type_size);
test_error(errNum, "clGetDeviceInfo failed"); ASSERT_SUCCESS(errNum, "clGetDeviceInfo");
if (handle_type_size == 0) if (handle_type_size == 0)
{ {
@@ -549,31 +549,37 @@ cl_int check_external_semaphore_handle_type(
queryParamName == CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR queryParamName == CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR
? "importing" ? "importing"
: "exporting"); : "exporting");
return CL_INVALID_VALUE;
throw std::runtime_error("");
} }
handle_type = handle_type =
(cl_external_semaphore_handle_type_khr *)malloc(handle_type_size); (cl_external_semaphore_handle_type_khr *)malloc(handle_type_size);
errNum = clGetDeviceInfo(deviceID, queryParamName, handle_type_size, errNum = clGetDeviceInfo(device, queryParamName, handle_type_size,
handle_type, NULL); handle_type, NULL);
ASSERT_SUCCESS(errNum, "clGetDeviceInfo");
test_error( bool found = false;
errNum,
"Unable to query supported device semaphore handle types list\n");
for (i = 0; i < handle_type_size; i++) for (i = 0; i < handle_type_size; i++)
{ {
if (requiredHandleType == handle_type[i]) if (requiredHandleType == handle_type[i])
{ {
return CL_SUCCESS; found = true;
break;
} }
} }
log_error("cl_khr_external_semaphore extension is missing support for %d\n",
requiredHandleType);
return CL_INVALID_VALUE; if (!found)
{
log_error("cl_khr_external_semaphore extension is missing support for "
"handle type %d\n",
requiredHandleType);
throw std::runtime_error("");
}
} }
clExternalMemory::clExternalMemory() {} clExternalMemory::clExternalMemory() {}
clExternalMemory::clExternalMemory(const clExternalMemory &externalMemory) clExternalMemory::clExternalMemory(const clExternalMemory &externalMemory)
@@ -859,9 +865,15 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
cl_device_id deviceId) cl_device_id deviceId)
: m_deviceSemaphore(semaphore) : m_deviceSemaphore(semaphore)
{ {
cl_int err = 0; cl_int err = 0;
cl_device_id devList[] = { deviceId, NULL }; cl_device_id devList[] = { deviceId, NULL };
cl_external_semaphore_handle_type_khr clSemaphoreHandleType =
getCLSemaphoreTypeFromVulkanType(externalSemaphoreHandleType);
check_external_semaphore_handle_type(
deviceId, clSemaphoreHandleType,
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
m_externalHandleType = externalSemaphoreHandleType; m_externalHandleType = externalSemaphoreHandleType;
m_externalSemaphore = nullptr; m_externalSemaphore = nullptr;
m_device = deviceId; m_device = deviceId;
@@ -879,8 +891,6 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
ASSERT(0); ASSERT(0);
#else #else
fd = (int)semaphore.getHandle(externalSemaphoreHandleType); fd = (int)semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props.push_back( sema_props.push_back(
(cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR); (cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props.push_back((cl_semaphore_properties_khr)fd); sema_props.push_back((cl_semaphore_properties_khr)fd);
@@ -892,8 +902,6 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
ASSERT(0); ASSERT(0);
#else #else
handle = semaphore.getHandle(externalSemaphoreHandleType); handle = 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) sema_props.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR); CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props.push_back((cl_semaphore_properties_khr)handle); sema_props.push_back((cl_semaphore_properties_khr)handle);
@@ -907,8 +915,6 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
const std::wstring &name = semaphore.getName(); const std::wstring &name = semaphore.getName();
if (name.size()) if (name.size())
{ {
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_NAME_KHR);
sema_props.push_back( sema_props.push_back(
(cl_semaphore_properties_khr) (cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_NAME_KHR); CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_NAME_KHR);
@@ -928,21 +934,17 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
ASSERT(0); ASSERT(0);
#else #else
handle = semaphore.getHandle(externalSemaphoreHandleType); 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) sema_props.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR); CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props.push_back((cl_semaphore_properties_khr)handle); sema_props.push_back((cl_semaphore_properties_khr)handle);
#endif #endif
break; break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
sema_props.push_back(static_cast<cl_semaphore_properties_khr>( sema_props.push_back(static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_HANDLE_SYNC_FD_KHR)); CL_SEMAPHORE_HANDLE_SYNC_FD_KHR));
sema_props.push_back(static_cast<cl_semaphore_properties_khr>(-1)); sema_props.push_back(static_cast<cl_semaphore_properties_khr>(-1));
break; break;
default: default:
log_error("Unsupported external memory handle type\n"); log_error("Unsupported external memory handle type\n");
ASSERT(0); ASSERT(0);
@@ -1017,11 +1019,15 @@ clExternalExportableSemaphore::clExternalExportableSemaphore(
cl_device_id deviceId) cl_device_id deviceId)
: m_deviceSemaphore(semaphore) : m_deviceSemaphore(semaphore)
{ {
cl_int err = 0; cl_int err = 0;
cl_device_id devList[] = { deviceId, NULL }; cl_device_id devList[] = { deviceId, NULL };
cl_external_semaphore_handle_type_khr clSemaphoreHandleType = cl_external_semaphore_handle_type_khr clSemaphoreHandleType =
getCLSemaphoreTypeFromVulkanType(externalSemaphoreHandleType); getCLSemaphoreTypeFromVulkanType(externalSemaphoreHandleType);
check_external_semaphore_handle_type(
deviceId, clSemaphoreHandleType,
CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR);
m_externalHandleType = externalSemaphoreHandleType; m_externalHandleType = externalSemaphoreHandleType;
m_externalSemaphore = nullptr; m_externalSemaphore = nullptr;
m_device = deviceId; m_device = deviceId;

24
test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp
View File

@@ -28,23 +28,6 @@
#include <optional> #include <optional>
#define CREATE_OPENCL_SEMAPHORE(clSemaphore, vkSemaphore, ctx, handleType, \
devIdx, createExportable) \
if (!(createExportable \
&& (check_external_semaphore_handle_type( \
devIdx, getCLSemaphoreTypeFromVulkanType(handleType), \
CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR) \
== CL_SUCCESS))) \
{ \
clSemaphore = new clExternalImportableSemaphore(vkSemaphore, ctx, \
handleType, devIdx); \
} \
else \
{ \
clSemaphore = new clExternalExportableSemaphore(vkSemaphore, ctx, \
handleType, devIdx); \
}
typedef cl_semaphore_khr (*pfnclCreateSemaphoreWithPropertiesKHR)( typedef cl_semaphore_khr (*pfnclCreateSemaphoreWithPropertiesKHR)(
cl_context context, cl_semaphore_properties_khr *sema_props, cl_context context, cl_semaphore_properties_khr *sema_props,
cl_int *errcode_ret); cl_int *errcode_ret);
@@ -93,11 +76,10 @@ cl_int getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *, size_t,
cl_int check_external_memory_handle_type( cl_int check_external_memory_handle_type(
cl_device_id deviceID, cl_device_id deviceID,
cl_external_memory_handle_type_khr requiredHandleType); cl_external_memory_handle_type_khr requiredHandleType);
cl_int check_external_semaphore_handle_type( void check_external_semaphore_handle_type(
cl_device_id deviceID, cl_device_id device,
cl_external_semaphore_handle_type_khr requiredHandleType, cl_external_semaphore_handle_type_khr requiredHandleType,
cl_device_info queryParamName = cl_device_info queryParamName);
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
cl_int setMaxImageDimensions(cl_device_id deviceID, size_t &width, cl_int setMaxImageDimensions(cl_device_id deviceID, size_t &width,
size_t &height); size_t &height);

135
test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp
View File

@@ -361,10 +361,8 @@ int test_external_semaphores_simple_1(cl_device_id device, cl_context context,
VulkanSemaphore vkVk2CLSemaphore(vkDevice, VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL; auto sema_ext = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -375,14 +373,13 @@ int test_external_semaphores_simple_1(cl_device_id device, cl_context context,
// Signal semaphore // Signal semaphore
clEventWrapper signal_event; clEventWrapper signal_event;
err = err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), nullptr, 0, nullptr, &signal_event);
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore // Wait semaphore
clEventWrapper wait_event; clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &wait_event); nullptr, 0, nullptr, &wait_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
@@ -435,10 +432,8 @@ int test_external_semaphores_simple_2(cl_device_id device, cl_context context,
VulkanSemaphore vkVk2CLSemaphore(vkDevice, VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL; auto sema_ext = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -465,14 +460,13 @@ int test_external_semaphores_simple_2(cl_device_id device, cl_context context,
// Signal semaphore // Signal semaphore
clEventWrapper signal_event; clEventWrapper signal_event;
err = err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), nullptr, 0, nullptr, &signal_event);
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore // Wait semaphore
clEventWrapper wait_event; clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &wait_event); nullptr, 0, nullptr, &wait_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
@@ -542,10 +536,8 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context,
VulkanSemaphore vkVk2CLSemaphore(vkDevice, VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL; auto sema_ext = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -571,9 +563,9 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context,
test_error(err, "Unable to enqueue task_1"); test_error(err, "Unable to enqueue task_1");
// Signal semaphore (dependency on task_1) // Signal semaphore (dependency on task_1)
err = clEnqueueSignalSemaphoresKHR( err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
queue, 1, &sema_ext->getCLSemaphore(), nullptr, 1, &task_events[0], nullptr, 1, &task_events[0],
&signal_events[0]); &signal_events[0]);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// In a loop // In a loop
@@ -582,7 +574,7 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context,
{ {
// Wait semaphore // Wait semaphore
err = clEnqueueWaitSemaphoresKHR( err = clEnqueueWaitSemaphoresKHR(
queue, 1, &sema_ext->getCLSemaphore(), nullptr, 0, nullptr, queue, 1, &sema_ext.getCLSemaphore(), nullptr, 0, nullptr,
&wait_events[loop - 1]); &wait_events[loop - 1]);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
@@ -597,13 +589,13 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context,
// Signal semaphore (dependency on task_loop) // Signal semaphore (dependency on task_loop)
err = clEnqueueSignalSemaphoresKHR( err = clEnqueueSignalSemaphoresKHR(
queue, 1, &sema_ext->getCLSemaphore(), nullptr, 1, queue, 1, &sema_ext.getCLSemaphore(), nullptr, 1,
&task_events[loop], &signal_events[loop]); &task_events[loop], &signal_events[loop]);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
} }
// Wait semaphore // Wait semaphore
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, nullptr, 0, nullptr,
&wait_events[loop - 1]); &wait_events[loop - 1]);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
@@ -662,25 +654,22 @@ static int external_semaphore_cross_queue_helper(cl_device_id device,
VulkanSemaphore vkVk2CLSemaphore(vkDevice, VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL; auto sema_ext = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
// Signal semaphore on queue_1 // Signal semaphore on queue_1
clEventWrapper signal_event; clEventWrapper signal_event;
err = clEnqueueSignalSemaphoresKHR(queue_1, 1, err =
&sema_ext->getCLSemaphore(), nullptr, clEnqueueSignalSemaphoresKHR(queue_1, 1, &sema_ext.getCLSemaphore(),
0, nullptr, &signal_event); nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore on queue_2 // Wait semaphore on queue_2
clEventWrapper wait_event; clEventWrapper wait_event;
err = err = clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext.getCLSemaphore(),
clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext->getCLSemaphore(), nullptr, 0, nullptr, &wait_event);
nullptr, 0, nullptr, &wait_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
// Finish queue_1 and queue_2 // Finish queue_1 and queue_2
@@ -786,15 +775,11 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device,
VulkanSemaphore vkVk2CLSemaphore(vkDevice, VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext_1 = NULL; auto sema_ext_1 = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore, context, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_1(raw_sema_ext_1);
clExternalSemaphore *raw_sema_ext_2 = NULL; auto sema_ext_2 = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore, context2, vkVk2CLSemaphore, context2, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_2(raw_sema_ext_2);
clCommandQueueWrapper queue1 = clCommandQueueWrapper queue1 =
clCreateCommandQueue(context, device, 0, &err); clCreateCommandQueue(context, device, 0, &err);
@@ -807,28 +792,28 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device,
// Signal semaphore 1 // Signal semaphore 1
clEventWrapper signal_1_event; clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR( err = clEnqueueSignalSemaphoresKHR(
queue1, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr, queue1, 1, &sema_ext_1.getCLSemaphore(), nullptr, 0, nullptr,
&signal_1_event); &signal_1_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore 1 // Wait semaphore 1
clEventWrapper wait_1_event; clEventWrapper wait_1_event;
err = err =
clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1->getCLSemaphore(), clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(),
nullptr, 0, nullptr, &wait_1_event); nullptr, 0, nullptr, &wait_1_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
// Signal semaphore 2 // Signal semaphore 2
clEventWrapper signal_2_event; clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR( err = clEnqueueSignalSemaphoresKHR(
queue2, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr, queue2, 1, &sema_ext_2.getCLSemaphore(), nullptr, 0, nullptr,
&signal_2_event); &signal_2_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore 2 // Wait semaphore 2
clEventWrapper wait_2_event; clEventWrapper wait_2_event;
err = err =
clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2->getCLSemaphore(), clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(),
nullptr, 0, nullptr, &wait_2_event); nullptr, 0, nullptr, &wait_2_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
@@ -888,15 +873,11 @@ int test_external_semaphores_multi_signal(cl_device_id device,
VulkanSemaphore vkVk2CLSemaphore2(vkDevice, VulkanSemaphore vkVk2CLSemaphore2(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext_1 = NULL; auto sema_ext_1 = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore1, context, vkVk2CLSemaphore1, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_1(raw_sema_ext_1);
clExternalSemaphore *raw_sema_ext_2 = NULL; auto sema_ext_2 = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore2, context, vkVk2CLSemaphore2, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_2(raw_sema_ext_2);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -907,24 +888,22 @@ int test_external_semaphores_multi_signal(cl_device_id device,
// Signal semaphore 1 and 2 // Signal semaphore 1 and 2
clEventWrapper signal_event; clEventWrapper signal_event;
cl_semaphore_khr sema_list[] = { sema_ext_1->getCLSemaphore(), cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(),
sema_ext_2->getCLSemaphore() }; sema_ext_2.getCLSemaphore() };
err = clEnqueueSignalSemaphoresKHR(queue, 2, sema_list, nullptr, 0, err = clEnqueueSignalSemaphoresKHR(queue, 2, sema_list, nullptr, 0,
nullptr, &signal_event); nullptr, &signal_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore 1 // Wait semaphore 1
clEventWrapper wait_1_event; clEventWrapper wait_1_event;
err = err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(),
clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr, &wait_1_event);
nullptr, 0, nullptr, &wait_1_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
// Wait semaphore 2 // Wait semaphore 2
clEventWrapper wait_2_event; clEventWrapper wait_2_event;
err = err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(),
clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr, &wait_2_event);
nullptr, 0, nullptr, &wait_2_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");
// Finish // Finish
@@ -978,15 +957,11 @@ int test_external_semaphores_multi_wait(cl_device_id device, cl_context context,
VulkanSemaphore vkVk2CLSemaphore2(vkDevice, VulkanSemaphore vkVk2CLSemaphore2(vkDevice,
vkExternalSemaphoreHandleType); vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext_1 = NULL; auto sema_ext_1 = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore1, context, vkVk2CLSemaphore1, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_1(raw_sema_ext_1);
clExternalSemaphore *raw_sema_ext_2 = NULL; auto sema_ext_2 = clExternalImportableSemaphore(
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore2, context, vkVk2CLSemaphore2, context, vkExternalSemaphoreHandleType, device);
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_2(raw_sema_ext_2);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -997,22 +972,22 @@ int test_external_semaphores_multi_wait(cl_device_id device, cl_context context,
// Signal semaphore 1 // Signal semaphore 1
clEventWrapper signal_1_event; clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR( err =
queue, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr, clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(),
&signal_1_event); nullptr, 0, nullptr, &signal_1_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Signal semaphore 2 // Signal semaphore 2
clEventWrapper signal_2_event; clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR( err =
queue, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr, clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(),
&signal_2_event); nullptr, 0, nullptr, &signal_2_event);
test_error(err, "Could not signal semaphore"); test_error(err, "Could not signal semaphore");
// Wait semaphore 1 and 2 // Wait semaphore 1 and 2
clEventWrapper wait_event; clEventWrapper wait_event;
cl_semaphore_khr sema_list[] = { sema_ext_1->getCLSemaphore(), cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(),
sema_ext_2->getCLSemaphore() }; sema_ext_2.getCLSemaphore() };
err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 0, err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 0,
nullptr, &wait_event); nullptr, &wait_event);
test_error(err, "Could not wait semaphore"); test_error(err, "Could not wait semaphore");

15
test_conformance/vulkan/test_vulkan_api_consistency.cpp
View File

@@ -381,6 +381,10 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
for (VulkanExternalSemaphoreHandleType semaphoreHandleType : for (VulkanExternalSemaphoreHandleType semaphoreHandleType :
supportedExternalSemaphores) supportedExternalSemaphores)
{ {
check_external_semaphore_handle_type(
device, getCLSemaphoreTypeFromVulkanType(semaphoreHandleType),
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
VulkanSemaphore vkVk2Clsemaphore(*vkDevice, semaphoreHandleType); VulkanSemaphore vkVk2Clsemaphore(*vkDevice, semaphoreHandleType);
VulkanSemaphore vkCl2Vksemaphore(*vkDevice, semaphoreHandleType); VulkanSemaphore vkCl2Vksemaphore(*vkDevice, semaphoreHandleType);
cl_semaphore_khr clCl2Vksemaphore; cl_semaphore_khr clCl2Vksemaphore;
@@ -396,6 +400,7 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR, (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR, (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
}; };
switch (semaphoreHandleType) switch (semaphoreHandleType)
{ {
#ifdef _WIN32 #ifdef _WIN32
@@ -404,8 +409,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
" Opaque NT handles are only supported on Windows\n"); " Opaque NT handles are only supported on Windows\n");
handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType); handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType);
handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType); handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType);
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props1.push_back( sema_props1.push_back(
(cl_semaphore_properties_khr) (cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR); CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
@@ -420,8 +423,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
"Windows\n"); "Windows\n");
handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType); handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType);
handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType); handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType);
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props1.push_back( sema_props1.push_back(
(cl_semaphore_properties_khr) (cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR); CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
@@ -435,8 +436,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
fd1 = (int)vkVk2Clsemaphore.getHandle(semaphoreHandleType); fd1 = (int)vkVk2Clsemaphore.getHandle(semaphoreHandleType);
fd2 = (int)vkCl2Vksemaphore.getHandle(semaphoreHandleType); fd2 = (int)vkCl2Vksemaphore.getHandle(semaphoreHandleType);
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props1.push_back( sema_props1.push_back(
(cl_semaphore_properties_khr) (cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR); CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
@@ -449,8 +448,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
fd1 = -1; fd1 = -1;
fd2 = -1; fd2 = -1;
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
sema_props1.push_back((cl_semaphore_properties_khr) sema_props1.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_SYNC_FD_KHR); CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)fd1); sema_props1.push_back((cl_semaphore_properties_khr)fd1);
@@ -466,7 +463,7 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
if (CL_SUCCESS != errNum) if (CL_SUCCESS != errNum)
{ {
throw std::runtime_error( throw std::runtime_error(
"Unsupported external sempahore handle type\n "); "Unsupported external semaphore handle type\n ");
} }
sema_props1.push_back((cl_semaphore_properties_khr) sema_props1.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR); CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR);

77
test_conformance/vulkan/test_vulkan_interop_buffer.cpp
View File

@@ -98,8 +98,8 @@ int run_test_with_two_queue(
cl_mem error_1 = nullptr; cl_mem error_1 = nullptr;
cl_kernel update_buffer_kernel = nullptr; cl_kernel update_buffer_kernel = nullptr;
cl_kernel kernel_cq = nullptr; cl_kernel kernel_cq = nullptr;
clExternalSemaphore *clVk2CLExternalSemaphore = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
const char *program_source_const = kernel_text_numbuffer_2; const char *program_source_const = kernel_text_numbuffer_2;
size_t program_source_length = strlen(program_source_const); size_t program_source_length = strlen(program_source_const);
cl_program program = clCreateProgramWithSource( cl_program program = clCreateProgramWithSource(
@@ -147,12 +147,11 @@ int run_test_with_two_queue(
} }
else else
{ {
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
context, vkExternalSemaphoreHandleType, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
context, vkExternalSemaphoreHandleType, vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, true);
} }
const uint32_t maxIter = innerIterations; const uint32_t maxIter = innerIterations;
@@ -442,8 +441,8 @@ int run_test_with_one_queue(
uint8_t *error_2 = nullptr; uint8_t *error_2 = nullptr;
cl_mem error_1 = nullptr; cl_mem error_1 = nullptr;
cl_kernel update_buffer_kernel; cl_kernel update_buffer_kernel;
clExternalSemaphore *clVk2CLExternalSemaphore = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
int err = CL_SUCCESS; int err = CL_SUCCESS;
const std::vector<VulkanExternalMemoryHandleType> const std::vector<VulkanExternalMemoryHandleType>
@@ -482,12 +481,11 @@ int run_test_with_one_queue(
} }
else else
{ {
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
context, vkExternalSemaphoreHandleType, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
context, vkExternalSemaphoreHandleType, vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, true);
} }
const uint32_t maxIter = innerIterations; const uint32_t maxIter = innerIterations;
@@ -747,8 +745,8 @@ int run_test_with_multi_import_same_ctx(
cl_mem error_1 = nullptr; cl_mem error_1 = nullptr;
int numImports = numBuffers; int numImports = numBuffers;
cl_kernel update_buffer_kernel; cl_kernel update_buffer_kernel;
clExternalSemaphore *clVk2CLExternalSemaphore = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
int err = CL_SUCCESS; int err = CL_SUCCESS;
int calc_max_iter; int calc_max_iter;
@@ -787,12 +785,11 @@ int run_test_with_multi_import_same_ctx(
} }
else else
{ {
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
context, vkExternalSemaphoreHandleType, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
context, vkExternalSemaphoreHandleType, vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, true);
} }
const uint32_t maxIter = innerIterations; const uint32_t maxIter = innerIterations;
@@ -1084,10 +1081,10 @@ int run_test_with_multi_import_diff_ctx(
int numImports = numBuffers; int numImports = numBuffers;
cl_kernel update_buffer_kernel1[MAX_IMPORTS]; cl_kernel update_buffer_kernel1[MAX_IMPORTS];
cl_kernel update_buffer_kernel2[MAX_IMPORTS]; cl_kernel update_buffer_kernel2[MAX_IMPORTS];
clExternalSemaphore *clVk2CLExternalSemaphore = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
clExternalSemaphore *clVk2CLExternalSemaphore2 = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore2 = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore2 = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore2 = nullptr;
int err = CL_SUCCESS; int err = CL_SUCCESS;
int calc_max_iter; int calc_max_iter;
bool withOffset; bool withOffset;
@@ -1128,19 +1125,19 @@ int run_test_with_multi_import_diff_ctx(
} }
else else
{ {
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
context, vkExternalSemaphoreHandleType, vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore2, vkVk2CLSemaphore, clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
context2, vkExternalSemaphoreHandleType, vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore2, vkCl2VkSemaphore, clVk2CLExternalSemaphore2 = new clExternalImportableSemaphore(
context2, vkExternalSemaphoreHandleType, vkVk2CLSemaphore, context2, vkExternalSemaphoreHandleType,
deviceId, false); deviceId);
clCl2VkExternalSemaphore2 = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context2, vkExternalSemaphoreHandleType,
deviceId);
} }
const uint32_t maxIter = innerIterations; const uint32_t maxIter = innerIterations;

26
test_conformance/vulkan/test_vulkan_interop_image.cpp
View File

@@ -254,13 +254,14 @@ int run_test_with_two_queue(
VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType);
VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType); VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore *clVk2CLExternalSemaphore = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, context, clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkExternalSemaphoreHandleType, deviceId, false); vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, context,
vkExternalSemaphoreHandleType, deviceId, true); clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;
@@ -873,13 +874,14 @@ int run_test_with_one_queue(
VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType);
VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType); VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore *clVk2CLExternalSemaphore = NULL; clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL; clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, context, clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkExternalSemaphoreHandleType, deviceId, false); vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, context,
vkExternalSemaphoreHandleType, deviceId, true); clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2; std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;