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

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

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

@@ -28,23 +28,6 @@
#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)(
cl_context context, cl_semaphore_properties_khr *sema_props,
cl_int *errcode_ret);
@@ -93,11 +76,10 @@ cl_int getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *, size_t,
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,
void check_external_semaphore_handle_type(
cl_device_id device,
cl_external_semaphore_handle_type_khr requiredHandleType,
cl_device_info queryParamName =
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
cl_device_info queryParamName);
cl_int setMaxImageDimensions(cl_device_id deviceID, size_t &width,
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,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
auto sema_ext = clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
cl_int err = CL_SUCCESS;
@@ -375,14 +373,13 @@ int test_external_semaphores_simple_1(cl_device_id device, cl_context context,
// Signal semaphore
clEventWrapper signal_event;
err =
clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(),
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &wait_event);
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,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
auto sema_ext = clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
cl_int err = CL_SUCCESS;
@@ -465,14 +460,13 @@ int test_external_semaphores_simple_2(cl_device_id device, cl_context context,
// Signal semaphore
clEventWrapper signal_event;
err =
clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(),
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &wait_event);
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,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
auto sema_ext = clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
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");
// Signal semaphore (dependency on task_1)
err = clEnqueueSignalSemaphoresKHR(
queue, 1, &sema_ext->getCLSemaphore(), nullptr, 1, &task_events[0],
&signal_events[0]);
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &task_events[0],
&signal_events[0]);
test_error(err, "Could not signal semaphore");
// In a loop
@@ -582,7 +574,7 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context,
{
// Wait semaphore
err = clEnqueueWaitSemaphoresKHR(
queue, 1, &sema_ext->getCLSemaphore(), nullptr, 0, nullptr,
queue, 1, &sema_ext.getCLSemaphore(), nullptr, 0, nullptr,
&wait_events[loop - 1]);
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)
err = clEnqueueSignalSemaphoresKHR(
queue, 1, &sema_ext->getCLSemaphore(), nullptr, 1,
queue, 1, &sema_ext.getCLSemaphore(), nullptr, 1,
&task_events[loop], &signal_events[loop]);
test_error(err, "Could not signal semaphore");
}
// Wait semaphore
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(),
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr,
&wait_events[loop - 1]);
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,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext(raw_sema_ext);
auto sema_ext = clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
cl_int err = CL_SUCCESS;
// Signal semaphore on queue_1
clEventWrapper signal_event;
err = clEnqueueSignalSemaphoresKHR(queue_1, 1,
&sema_ext->getCLSemaphore(), nullptr,
0, nullptr, &signal_event);
err =
clEnqueueSignalSemaphoresKHR(queue_1, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore on queue_2
clEventWrapper wait_event;
err =
clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext->getCLSemaphore(),
nullptr, 0, nullptr, &wait_event);
err = clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &wait_event);
test_error(err, "Could not wait semaphore");
// Finish queue_1 and queue_2
@@ -786,15 +775,11 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device,
VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext_1 = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_1(raw_sema_ext_1);
auto sema_ext_1 = clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
clExternalSemaphore *raw_sema_ext_2 = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore, context2,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_2(raw_sema_ext_2);
auto sema_ext_2 = clExternalImportableSemaphore(
vkVk2CLSemaphore, context2, vkExternalSemaphoreHandleType, device);
clCommandQueueWrapper queue1 =
clCreateCommandQueue(context, device, 0, &err);
@@ -807,28 +792,28 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device,
// Signal semaphore 1
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(
queue1, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr,
queue1, 1, &sema_ext_1.getCLSemaphore(), nullptr, 0, nullptr,
&signal_1_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore 1
clEventWrapper wait_1_event;
err =
clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1->getCLSemaphore(),
clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(),
nullptr, 0, nullptr, &wait_1_event);
test_error(err, "Could not wait semaphore");
// Signal semaphore 2
clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR(
queue2, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr,
queue2, 1, &sema_ext_2.getCLSemaphore(), nullptr, 0, nullptr,
&signal_2_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore 2
clEventWrapper wait_2_event;
err =
clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2->getCLSemaphore(),
clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(),
nullptr, 0, nullptr, &wait_2_event);
test_error(err, "Could not wait semaphore");
@@ -888,15 +873,11 @@ int test_external_semaphores_multi_signal(cl_device_id device,
VulkanSemaphore vkVk2CLSemaphore2(vkDevice,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext_1 = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore1, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_1(raw_sema_ext_1);
auto sema_ext_1 = clExternalImportableSemaphore(
vkVk2CLSemaphore1, context, vkExternalSemaphoreHandleType, device);
clExternalSemaphore *raw_sema_ext_2 = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore2, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_2(raw_sema_ext_2);
auto sema_ext_2 = clExternalImportableSemaphore(
vkVk2CLSemaphore2, context, vkExternalSemaphoreHandleType, device);
cl_int err = CL_SUCCESS;
@@ -907,24 +888,22 @@ int test_external_semaphores_multi_signal(cl_device_id device,
// Signal semaphore 1 and 2
clEventWrapper signal_event;
cl_semaphore_khr sema_list[] = { sema_ext_1->getCLSemaphore(),
sema_ext_2->getCLSemaphore() };
cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(),
sema_ext_2.getCLSemaphore() };
err = clEnqueueSignalSemaphoresKHR(queue, 2, sema_list, nullptr, 0,
nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore 1
clEventWrapper wait_1_event;
err =
clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1->getCLSemaphore(),
nullptr, 0, nullptr, &wait_1_event);
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(),
nullptr, 0, nullptr, &wait_1_event);
test_error(err, "Could not wait semaphore");
// Wait semaphore 2
clEventWrapper wait_2_event;
err =
clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2->getCLSemaphore(),
nullptr, 0, nullptr, &wait_2_event);
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(),
nullptr, 0, nullptr, &wait_2_event);
test_error(err, "Could not wait semaphore");
// Finish
@@ -978,15 +957,11 @@ int test_external_semaphores_multi_wait(cl_device_id device, cl_context context,
VulkanSemaphore vkVk2CLSemaphore2(vkDevice,
vkExternalSemaphoreHandleType);
clExternalSemaphore *raw_sema_ext_1 = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore1, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_1(raw_sema_ext_1);
auto sema_ext_1 = clExternalImportableSemaphore(
vkVk2CLSemaphore1, context, vkExternalSemaphoreHandleType, device);
clExternalSemaphore *raw_sema_ext_2 = NULL;
CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore2, context,
vkExternalSemaphoreHandleType, device, true);
std::unique_ptr<clExternalSemaphore> sema_ext_2(raw_sema_ext_2);
auto sema_ext_2 = clExternalImportableSemaphore(
vkVk2CLSemaphore2, context, vkExternalSemaphoreHandleType, device);
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
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(
queue, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr,
&signal_1_event);
err =
clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(),
nullptr, 0, nullptr, &signal_1_event);
test_error(err, "Could not signal semaphore");
// Signal semaphore 2
clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR(
queue, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr,
&signal_2_event);
err =
clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(),
nullptr, 0, nullptr, &signal_2_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore 1 and 2
clEventWrapper wait_event;
cl_semaphore_khr sema_list[] = { sema_ext_1->getCLSemaphore(),
sema_ext_2->getCLSemaphore() };
cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(),
sema_ext_2.getCLSemaphore() };
err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 0,
nullptr, &wait_event);
test_error(err, "Could not wait semaphore");

15
test_conformance/vulkan/test_vulkan_api_consistency.cpp
View File

@@ -381,6 +381,10 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
for (VulkanExternalSemaphoreHandleType semaphoreHandleType :
supportedExternalSemaphores)
{
check_external_semaphore_handle_type(
device, getCLSemaphoreTypeFromVulkanType(semaphoreHandleType),
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
VulkanSemaphore vkVk2Clsemaphore(*vkDevice, semaphoreHandleType);
VulkanSemaphore vkCl2Vksemaphore(*vkDevice, semaphoreHandleType);
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_BINARY_KHR,
};
switch (semaphoreHandleType)
{
#ifdef _WIN32
@@ -404,8 +409,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
" Opaque NT handles are only supported on Windows\n");
handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType);
handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType);
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props1.push_back(
(cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
@@ -420,8 +423,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
"Windows\n");
handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType);
handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType);
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props1.push_back(
(cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
@@ -435,8 +436,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
fd1 = (int)vkVk2Clsemaphore.getHandle(semaphoreHandleType);
fd2 = (int)vkCl2Vksemaphore.getHandle(semaphoreHandleType);
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props1.push_back(
(cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
@@ -449,8 +448,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
fd1 = -1;
fd2 = -1;
errNum = check_external_semaphore_handle_type(
device, CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
sema_props1.push_back((cl_semaphore_properties_khr)fd1);
@@ -466,7 +463,7 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
if (CL_SUCCESS != errNum)
{
throw std::runtime_error(
"Unsupported external sempahore handle type\n ");
"Unsupported external semaphore handle type\n ");
}
sema_props1.push_back((cl_semaphore_properties_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_kernel update_buffer_kernel = nullptr;
cl_kernel kernel_cq = nullptr;
clExternalSemaphore *clVk2CLExternalSemaphore = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL;
clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
const char *program_source_const = kernel_text_numbuffer_2;
size_t program_source_length = strlen(program_source_const);
cl_program program = clCreateProgramWithSource(
@@ -147,12 +147,11 @@ int run_test_with_two_queue(
}
else
{
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, true);
clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
}
const uint32_t maxIter = innerIterations;
@@ -442,8 +441,8 @@ int run_test_with_one_queue(
uint8_t *error_2 = nullptr;
cl_mem error_1 = nullptr;
cl_kernel update_buffer_kernel;
clExternalSemaphore *clVk2CLExternalSemaphore = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL;
clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
int err = CL_SUCCESS;
const std::vector<VulkanExternalMemoryHandleType>
@@ -482,12 +481,11 @@ int run_test_with_one_queue(
}
else
{
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, true);
clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
}
const uint32_t maxIter = innerIterations;
@@ -747,8 +745,8 @@ int run_test_with_multi_import_same_ctx(
cl_mem error_1 = nullptr;
int numImports = numBuffers;
cl_kernel update_buffer_kernel;
clExternalSemaphore *clVk2CLExternalSemaphore = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL;
clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
int err = CL_SUCCESS;
int calc_max_iter;
@@ -787,12 +785,11 @@ int run_test_with_multi_import_same_ctx(
}
else
{
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, true);
clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
}
const uint32_t maxIter = innerIterations;
@@ -1084,10 +1081,10 @@ int run_test_with_multi_import_diff_ctx(
int numImports = numBuffers;
cl_kernel update_buffer_kernel1[MAX_IMPORTS];
cl_kernel update_buffer_kernel2[MAX_IMPORTS];
clExternalSemaphore *clVk2CLExternalSemaphore = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL;
clExternalSemaphore *clVk2CLExternalSemaphore2 = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore2 = NULL;
clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
clExternalImportableSemaphore *clVk2CLExternalSemaphore2 = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore2 = nullptr;
int err = CL_SUCCESS;
int calc_max_iter;
bool withOffset;
@@ -1128,19 +1125,19 @@ int run_test_with_multi_import_diff_ctx(
}
else
{
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore,
context, vkExternalSemaphoreHandleType,
deviceId, false);
clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore2, vkVk2CLSemaphore,
context2, vkExternalSemaphoreHandleType,
deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore2, vkCl2VkSemaphore,
context2, vkExternalSemaphoreHandleType,
deviceId, false);
clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
clVk2CLExternalSemaphore2 = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context2, vkExternalSemaphoreHandleType,
deviceId);
clCl2VkExternalSemaphore2 = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context2, vkExternalSemaphoreHandleType,
deviceId);
}
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 vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore *clVk2CLExternalSemaphore = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL;
clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, context,
vkExternalSemaphoreHandleType, deviceId, true);
clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;
@@ -873,13 +874,14 @@ int run_test_with_one_queue(
VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType);
VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore *clVk2CLExternalSemaphore = NULL;
clExternalSemaphore *clCl2VkExternalSemaphore = NULL;
clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr;
clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr;
CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, deviceId, false);
CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, context,
vkExternalSemaphoreHandleType, deviceId, true);
clVk2CLExternalSemaphore = new clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
clCl2VkExternalSemaphore = new clExternalExportableSemaphore(
vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId);
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory1;
std::vector<VulkanDeviceMemory *> vkImage2DListDeviceMemory2;