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

Remove semaphores_simple_2 and external_semaphores_simple_2 tests (#2447)

Browse Source 
While the cl_khr_semaphore extension spec does state that are no
implicit dependencies between already enqueued commands and the
clEnqueueSignalSemaphoresKHR, it's nothing special as this is already
true for any other event that's not a barrier or marker.

Also, the CTS can't reliably assume implementations to reorder events
even in an out of order queue as this is highly implementation defined
behavior and implementations may or may not choose to reorder events in
a specific order.

I don't see a reason why this should be tested for semaphores, but not
for any other commands, especially as it imposes a restriction on how to
implement out of order queues that wasn't enforced before.

Closes: https://github.com/KhronosGroup/OpenCL-CTS/issues/2439
This commit is contained in:
Karol Herbst
2025-08-05 18:10:00 +02:00
committed by GitHub
parent c7abbe57a4
commit 678ad78233
2 changed files with 0 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -388,109 +388,6 @@ REGISTER_TEST_VERSION(external_semaphores_simple_1, Version(1, 2))
return TEST_PASS;
}
// Confirm that signal a semaphore with no event dependencies will not result
// in an implicit dependency on everything previously submitted
REGISTER_TEST_VERSION(external_semaphores_simple_2, Version(1, 2))
{
REQUIRE_EXTENSION("cl_khr_external_semaphore");
if (init_vulkan_device(1, &device))
{
log_info("Cannot initialise Vulkan. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
VulkanDevice vkDevice;
// Obtain pointers to semaphore's API
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
std::vector<VulkanExternalSemaphoreHandleType>
vkExternalSemaphoreHandleTypeList =
getSupportedInteropExternalSemaphoreHandleTypes(device, vkDevice);
if (vkExternalSemaphoreHandleTypeList.empty())
{
test_fail("No external semaphore handle types found\n");
}
for (VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType :
vkExternalSemaphoreHandleTypeList)
{
log_info_semaphore_type(vkExternalSemaphoreHandleType);
VulkanSemaphore vkVk2CLSemaphore(vkDevice,
vkExternalSemaphoreHandleType);
auto sema_ext = clExternalImportableSemaphore(
vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device);
cl_int err = CL_SUCCESS;
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create user event
clEventWrapper user_event = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Create Kernel
clProgramWrapper program;
clKernelWrapper kernel;
err = create_single_kernel_helper(context, &program, &kernel, 1,
&source, "empty");
test_error(err, "Could not create kernel");
// Enqueue task_1 (dependency on user_event)
clEventWrapper task_1_event;
err = clEnqueueTask(queue, kernel, 1, &user_event, &task_1_event);
test_error(err, "Could not enqueue task 1");
// Signal semaphore
clEventWrapper signal_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(),
nullptr, 0, nullptr, &wait_event);
test_error(err, "Could not wait semaphore");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
cl_event event_list[] = { signal_event, wait_event };
err = clWaitForEvents(2, event_list);
test_error(err, "Could not wait on events");
// Ensure all events are completed except for task_1
test_assert_event_inprogress(task_1_event);
test_assert_event_complete(signal_event);
test_assert_event_complete(wait_event);
// Complete user_event
err = clSetUserEventStatus(user_event, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(task_1_event);
test_assert_event_complete(signal_event);
test_assert_event_complete(wait_event);
}
return TEST_PASS;
}
// Confirm that a semaphore can be reused multiple times
REGISTER_TEST_VERSION(external_semaphores_reuse, Version(1, 2))
{

89
test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp
View File

@@ -76,87 +76,6 @@ struct SimpleSemaphore1 : public SemaphoreTestBase
}
};
struct SimpleSemaphore2 : public SemaphoreTestBase
{
SimpleSemaphore2(cl_device_id device, cl_context context,
cl_command_queue queue, cl_int nelems)
: SemaphoreTestBase(device, context, queue, nelems)
{}
cl_int Run() override
{
cl_int err = CL_SUCCESS;
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create semaphore
cl_semaphore_properties_khr sema_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_TYPE_BINARY_KHR),
0
};
semaphore =
clCreateSemaphoreWithPropertiesKHR(context, sema_props, &err);
test_error(err, "Could not create semaphore");
// Create user event
clEventWrapper user_event = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Create Kernel
clProgramWrapper program;
clKernelWrapper kernel;
err = create_single_kernel_helper(context, &program, &kernel, 1,
&source, "empty");
test_error(err, "Could not create kernel");
// Enqueue task_1 (dependency on user_event)
clEventWrapper task_1_event;
err = clEnqueueTask(queue, kernel, 1, &user_event, &task_1_event);
test_error(err, "Could not enqueue task 1");
// Signal semaphore
clEventWrapper signal_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, semaphore, nullptr, 0,
nullptr, &signal_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, semaphore, nullptr, 0,
nullptr, &wait_event);
test_error(err, "Could not wait semaphore");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure all events are completed except for task_1
test_assert_event_inprogress(task_1_event);
test_assert_event_complete(signal_event);
test_assert_event_complete(wait_event);
// Complete user_event
err = clSetUserEventStatus(user_event, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(task_1_event);
test_assert_event_complete(signal_event);
test_assert_event_complete(wait_event);
return CL_SUCCESS;
}
};
struct SemaphoreReuse : public SemaphoreTestBase
{
SemaphoreReuse(cl_device_id device, cl_context context,
@@ -387,14 +306,6 @@ REGISTER_TEST_VERSION(semaphores_simple_1, Version(1, 2))
num_elements);
}
// Confirm that signal a semaphore with no event dependencies will not result
// in an implicit dependency on everything previously submitted
REGISTER_TEST_VERSION(semaphores_simple_2, Version(1, 2))
{
return MakeAndRunTest<SimpleSemaphore2>(device, context, queue,
num_elements);
}
// Confirm that a semaphore can be reused multiple times
REGISTER_TEST_VERSION(semaphores_reuse, Version(1, 2))
{