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

Add testing for sync_fd (#1747)

Browse Source 
Modify the external semaphore extension test
to use SYNC_FD, if available on the device.

Deleted tests that are not compatible with blocking
semaphores.
This commit is contained in:
Sreelakshmi Haridas Maruthur
2023-08-01 12:03:00 -06:00
committed by GitHub
parent e29d0fd3a1
commit aa23f345c3
6 changed files with 87 additions and 435 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -740,21 +740,42 @@ clExternalSemaphore::clExternalSemaphore(
cl_int err = 0;
cl_device_id devList[] = { deviceId, NULL };
#ifdef _WIN32
if (!is_extension_available(devList[0], "cl_khr_external_semaphore_win32"))
switch (externalSemaphoreHandleType)
{
throw std::runtime_error("Device does not support "
"cl_khr_external_semaphore_win32 extension\n");
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
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");
}
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
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");
}
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
if (!is_extension_available(devList[0],
"cl_khr_external_semaphore_sync_fd"))
{
throw std::runtime_error(
"Device does not support cl_khr_external_semaphore_sync_fd "
"extension \n");
}
break;
default:
throw std::runtime_error(
"Unsupported external semaphore handle type\n");
break;
}
#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,
@@ -803,6 +824,16 @@ clExternalSemaphore::clExternalSemaphore(
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_EXPORT_HANDLE_TYPES_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>(
CL_SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR));
break;
default:
ASSERT(0);
log_error("Unsupported external memory handle type\n");

30
test_conformance/common/vulkan_wrapper/vulkan_utility.cpp
View File

@@ -248,6 +248,9 @@ getSupportedVulkanExternalSemaphoreHandleTypeList()
}
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT);
#elif defined(__ANDROID__)
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD);
#else
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD);
@@ -480,6 +483,33 @@ const std::vector<VulkanFormat> getSupportedVulkanFormatList()
return formatList;
}
cl_external_semaphore_handle_type_khr getCLSemaphoreTypeFromVulkanType(
VulkanExternalSemaphoreHandleType vulkanExternalSemaphoreHandleType)
{
cl_external_semaphore_handle_type_khr clExternalSemaphoreHandleTypeKhr = 0;
switch (vulkanExternalSemaphoreHandleType)
{
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
clExternalSemaphoreHandleTypeKhr =
CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR;
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
clExternalSemaphoreHandleTypeKhr =
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR;
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
clExternalSemaphoreHandleTypeKhr =
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR;
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
clExternalSemaphoreHandleTypeKhr = CL_SEMAPHORE_HANDLE_SYNC_FD_KHR;
break;
default: break;
}
return clExternalSemaphoreHandleTypeKhr;
}
uint32_t getVulkanFormatElementSize(VulkanFormat format)
{
switch (format)

2
test_conformance/common/vulkan_wrapper/vulkan_utility.hpp
View File

@@ -51,6 +51,8 @@ const std::vector<VulkanFormat> getSupportedVulkanFormatList();
uint32_t getVulkanFormatElementSize(VulkanFormat format);
const char* getVulkanFormatGLSLFormat(VulkanFormat format);
const char* getVulkanFormatGLSLTypePrefix(VulkanFormat format);
cl_external_semaphore_handle_type_khr getCLSemaphoreTypeFromVulkanType(
VulkanExternalSemaphoreHandleType vulkanExternalSemaphoreHandleType);
std::string prepareVulkanShader(
std::string shaderCode,

2
test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp
View File

@@ -72,6 +72,8 @@ VulkanInstance::VulkanInstance(): m_vkInstance(VK_NULL_HANDLE)
#if defined(_WIN32) || defined(_WIN64)
const char *vulkanLoaderLibraryName = "vulkan-1.dll";
#elif defined(__ANDROID__)
const char *vulkanLoaderLibraryName = "libvulkan.so";
#elif defined(__linux__)
const char *vulkanLoaderLibraryName = "libvulkan.so.1";
#endif

4
test_conformance/common/vulkan_wrapper/vulkan_wrapper_types.hpp
View File

@@ -169,7 +169,9 @@ enum VulkanExternalSemaphoreHandleType
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
| VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD =
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
};
enum VulkanBufferUsage

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

@@ -120,9 +120,11 @@ int test_external_semaphores_queries(cl_device_id deviceID, cl_context context,
SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_TYPE_KHR, cl_semaphore_type_khr,
CL_SEMAPHORE_TYPE_BINARY_KHR);
SEMAPHORE_PARAM_TEST(CL_DEVICE_HANDLE_LIST_KHR, cl_uint, 1);
SEMAPHORE_PARAM_TEST(CL_DEVICE_HANDLE_LIST_KHR, cl_device_id, deviceID);
SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, cl_uint, 1);
SEMAPHORE_PARAM_TEST(
CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, cl_uint,
getCLSemaphoreTypeFromVulkanType(vkExternalSemaphoreHandleType));
// Confirm that querying CL_SEMAPHORE_CONTEXT_KHR returns the right context
SEMAPHORE_PARAM_TEST(CL_SEMAPHORE_CONTEXT_KHR, cl_context, context);
@@ -290,7 +292,7 @@ static int semaphore_external_cross_queue_helper(cl_device_id deviceID,
nullptr, 0, nullptr, &wait_event);
test_error(err, "Could not wait semaphore");
// Finish queue_1 and queue_2
// Finish queue_1 and queue_2
err = clFinish(queue_1);
test_error(err, "Could not finish queue");
@@ -304,7 +306,7 @@ static int semaphore_external_cross_queue_helper(cl_device_id deviceID,
return TEST_PASS;
}
// Confirm that a signal followed by a wait will complete successfully
// Confirm that a signal followed by a wait will complete successfully
int test_external_semaphores_simple_1(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue,
int num_elements)
@@ -931,420 +933,3 @@ int test_external_semaphores_multi_wait(cl_device_id deviceID,
return TEST_PASS;
}
// Confirm that it is possible to enqueue a signal of wait and signal in any
// order as soon as the submission order (after deferred dependencies) is
// correct. Case: first one deferred wait, then one non deferred signal.
int test_external_semaphores_order_1(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue,
int num_elements)
{
if (!is_extension_available(deviceID, "cl_khr_external_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (init_vuikan_device())
{
log_info("Cannot initialise Vulkan. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
VulkanDevice vkDevice;
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
const std::vector<VulkanExternalMemoryHandleType>
vkExternalMemoryHandleTypeList =
getSupportedVulkanExternalMemoryHandleTypeList();
VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType =
getSupportedVulkanExternalSemaphoreHandleTypeList()[0];
VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore sema_ext(vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, deviceID);
cl_int err = CL_SUCCESS;
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create user event
clEventWrapper user_event = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Wait semaphore (dependency on user_event)
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event, &wait_event);
test_error(err, "Could not wait semaphore");
// Signal semaphore
clEventWrapper signal_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure signal event is completed while wait event is not
test_assert_event_complete(signal_event);
test_assert_event_inprogress(wait_event);
// Complete user_event
err = clSetUserEventStatus(user_event, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(signal_event);
test_assert_event_complete(wait_event);
return TEST_PASS;
}
// Confirm that it is possible to enqueue a signal of wait and signal in any
// order as soon as the submission order (after deferred dependencies) is
// correct. Case: first two deferred signals, then one deferred wait. Unblock
// signal, then unblock wait. When wait completes, unblock the other signal.
int test_external_semaphores_order_2(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue,
int num_elements)
{
if (!is_extension_available(deviceID, "cl_khr_external_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (init_vuikan_device())
{
log_info("Cannot initialise Vulkan. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
VulkanDevice vkDevice;
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
const std::vector<VulkanExternalMemoryHandleType>
vkExternalMemoryHandleTypeList =
getSupportedVulkanExternalMemoryHandleTypeList();
VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType =
getSupportedVulkanExternalSemaphoreHandleTypeList()[0];
VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore sema_ext(vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, deviceID);
cl_int err = CL_SUCCESS;
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create user events
clEventWrapper user_event_1 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_2 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_3 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Signal semaphore (dependency on user_event_1)
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_1,
&signal_1_event);
test_error(err, "Could not signal semaphore");
// Signal semaphore (dependency on user_event_2)
clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_2,
&signal_2_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore (dependency on user_event_3)
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_3, &wait_event);
test_error(err, "Could not wait semaphore");
// Complete user_event_1
err = clSetUserEventStatus(user_event_1, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Complete user_event_3
err = clSetUserEventStatus(user_event_3, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure all events are completed except for second signal
test_assert_event_complete(signal_1_event);
test_assert_event_inprogress(signal_2_event);
test_assert_event_complete(wait_event);
// Complete user_event_2
err = clSetUserEventStatus(user_event_2, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(signal_1_event);
test_assert_event_complete(signal_2_event);
test_assert_event_complete(wait_event);
return TEST_PASS;
}
// Confirm that it is possible to enqueue a signal of wait and signal in any
// order as soon as the submission order (after deferred dependencies) is
// correct. Case: first two deferred signals, then two deferred waits. Unblock
// one signal and one wait (both blocked by the same user event). When wait
// completes, unblock the other signal. Then unblock the other wait.
int test_external_semaphores_order_3(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue,
int num_elements)
{
if (!is_extension_available(deviceID, "cl_khr_external_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (init_vuikan_device())
{
log_info("Cannot initialise Vulkan. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
VulkanDevice vkDevice;
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
const std::vector<VulkanExternalMemoryHandleType>
vkExternalMemoryHandleTypeList =
getSupportedVulkanExternalMemoryHandleTypeList();
VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType =
getSupportedVulkanExternalSemaphoreHandleTypeList()[0];
VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore sema_ext(vkVk2CLSemaphore, context,
vkExternalSemaphoreHandleType, deviceID);
cl_int err = CL_SUCCESS;
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create user events
clEventWrapper user_event_1 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_2 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_3 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Signal semaphore (dependency on user_event_1)
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_1,
&signal_1_event);
test_error(err, "Could not signal semaphore");
// Signal semaphore (dependency on user_event_2)
clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_2,
&signal_2_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore (dependency on user_event_3)
clEventWrapper wait_1_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_3, &wait_1_event);
test_error(err, "Could not wait semaphore");
// Wait semaphore (dependency on user_event_2)
clEventWrapper wait_2_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 1, &user_event_2, &wait_2_event);
test_error(err, "Could not wait semaphore");
// Complete user_event_2
err = clSetUserEventStatus(user_event_2, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure only second signal and second wait completed
cl_event event_list[] = { signal_2_event, wait_2_event };
err = clWaitForEvents(2, event_list);
test_error(err, "Could not wait for events");
test_assert_event_inprogress(signal_1_event);
test_assert_event_inprogress(wait_1_event);
// Complete user_event_1
err = clSetUserEventStatus(user_event_1, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Complete user_event_3
err = clSetUserEventStatus(user_event_3, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(signal_1_event);
test_assert_event_complete(signal_2_event);
test_assert_event_complete(wait_1_event);
test_assert_event_complete(wait_2_event);
return TEST_PASS;
}
// Test that an invalid semaphore command results in the invalidation of the
// command's event and the dependencies' events
int test_external_semaphores_invalid_command(cl_device_id deviceID,
cl_context context,
cl_command_queue defaultQueue,
int num_elements)
{
if (!is_extension_available(deviceID, "cl_khr_external_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (init_vuikan_device())
{
log_info("Cannot initialise Vulkan. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
VulkanDevice vkDevice;
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
const std::vector<VulkanExternalMemoryHandleType>
vkExternalMemoryHandleTypeList =
getSupportedVulkanExternalMemoryHandleTypeList();
VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType =
getSupportedVulkanExternalSemaphoreHandleTypeList()[0];
VulkanSemaphore vkVk2CLSemaphore1(vkDevice, vkExternalSemaphoreHandleType);
VulkanSemaphore vkVk2CLSemaphore2(vkDevice, vkExternalSemaphoreHandleType);
clExternalSemaphore sema_ext_1(vkVk2CLSemaphore1, context,
vkExternalSemaphoreHandleType, deviceID);
clExternalSemaphore sema_ext_2(vkVk2CLSemaphore2, context,
vkExternalSemaphoreHandleType, deviceID);
cl_int err = CL_SUCCESS;
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create user events
clEventWrapper user_event_1 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_2 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Signal semaphore_1 (dependency on user_event_1)
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(),
nullptr, 1, &user_event_1,
&signal_1_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore_1 and semaphore_2 (dependency on user_event_1)
clEventWrapper wait_event;
cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(),
sema_ext_2.getCLSemaphore() };
err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 1,
&user_event_1, &wait_event);
test_error(err, "Could not wait semaphore");
// Signal semaphore_1 (dependency on wait_event and user_event_2)
clEventWrapper signal_2_event;
cl_event wait_list[] = { user_event_2, wait_event };
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(),
nullptr, 2, wait_list, &signal_2_event);
test_error(err, "Could not signal semaphore");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure all events are not completed
test_assert_event_inprogress(signal_1_event);
test_assert_event_inprogress(signal_2_event);
test_assert_event_inprogress(wait_event);
// Complete user_event_1 (expect failure as waiting on semaphore_2 is not
// allowed (unsignaled)
err = clSetUserEventStatus(user_event_1, CL_COMPLETE);
test_assert_error(err != CL_SUCCESS,
"signal_2_event completed unexpectedly");
// Ensure signal_1 is completed while others failed (the second signal
// should fail as it depends on wait)
err = clFinish(queue);
test_error(err, "Could not finish queue");
test_assert_event_complete(signal_1_event);
test_assert_event_terminated(wait_event);
test_assert_event_terminated(signal_2_event);
return TEST_PASS;
}