Add testing for sync_fd (#1747)

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

Deleted tests that are not compatible with blocking
semaphores.

test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp

@@ -740,21 +740,42 @@ clExternalSemaphore::clExternalSemaphore(
     cl_int err = 0;
     cl_device_id devList[] = { deviceId, NULL };
 
-#ifdef _WIN32
+    switch (externalSemaphoreHandleType)
-    if (!is_extension_available(devList[0], "cl_khr_external_semaphore_win32"))
     {
-        throw std::runtime_error("Device does not support "
+        case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
-                                 "cl_khr_external_semaphore_win32 extension\n");
+            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");

test_conformance/common/vulkan_wrapper/vulkan_utility.cpp

@@ -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)

test_conformance/common/vulkan_wrapper/vulkan_utility.hpp

@@ -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,

test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp

@@ -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

test_conformance/common/vulkan_wrapper/vulkan_wrapper_types.hpp

@@ -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

test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp

@@ -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;
-}