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

Clean up cl_khr_external_semaphore_dx_fence test (#2580)

Browse Source 
Removes the duplicated code from the tests. Improves the Base test
class.
This commit is contained in:
Jose Lopez
2026-01-20 18:02:26 +00:00
committed by GitHub
parent 5af0e74ef4
commit 584f27afd4
9 changed files with 662 additions and 673 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
test_common/harness/extensionHelpers.h
View File

@@ -32,5 +32,15 @@
} \
} while (false)
#define GET_FUNCTION_EXTENSION_ADDRESS(device, FUNC) \
FUNC = \
reinterpret_cast<FUNC##_fn>(clGetExtensionFunctionAddressForPlatform( \
getPlatformFromDevice(device), #FUNC)); \
if (FUNC == nullptr) \
{ \
log_error("ERROR: clGetExtensionFunctionAddressForPlatform failed" \
" with " #FUNC "\n"); \
return TEST_FAIL; \
}
#endif // _extensionHelpers_h

8
test_conformance/common/directx_wrapper/directx_wrapper.hpp
View File

@@ -26,9 +26,9 @@ class DirectXWrapper {
public:
DirectXWrapper();
ID3D12Device* getDXDevice() const;
ID3D12CommandQueue* getDXCommandQueue() const;
ID3D12CommandAllocator* getDXCommandAllocator() const;
[[nodiscard]] ID3D12Device* getDXDevice() const;
[[nodiscard]] ID3D12CommandQueue* getDXCommandQueue() const;
[[nodiscard]] ID3D12CommandAllocator* getDXCommandAllocator() const;
protected:
ComPtr<ID3D12Device> dx_device = nullptr;
@@ -39,7 +39,7 @@ protected:
class DirectXFenceWrapper {
public:
DirectXFenceWrapper(ID3D12Device* dx_device);
ID3D12Fence* operator*() const { return dx_fence.Get(); }
[[nodiscard]] ID3D12Fence* get() const { return dx_fence.Get(); }
private:
ComPtr<ID3D12Fence> dx_fence = nullptr;

3
test_conformance/extensions/cl_khr_external_semaphore_dx_fence/main.cpp
View File

@@ -17,6 +17,7 @@
int main(int argc, const char *argv[])
{
return runTestHarness(argc, argv, test_registry::getInstance().num_tests(),
return runTestHarness(
argc, argv, static_cast<int>(test_registry::getInstance().num_tests()),
test_registry::getInstance().definitions(), false, 0);
}

172
test_conformance/extensions/cl_khr_external_semaphore_dx_fence/semaphore_dx_fence_base.h
View File

@@ -21,81 +21,91 @@
#include "harness/errorHelpers.h"
#include "directx_wrapper.hpp"
class CLDXSemaphoreWrapper {
public:
CLDXSemaphoreWrapper(cl_device_id device, cl_context context,
ID3D12Device* dx_device)
: device(device), context(context), dx_device(dx_device){};
int createSemaphoreFromFence(ID3D12Fence* fence)
struct DXFenceTestBase
{
DXFenceTestBase(cl_device_id device, cl_context context,
cl_command_queue queue, cl_int num_elems)
: device(device), context(context), queue(queue), num_elems(num_elems)
{}
virtual ~DXFenceTestBase()
{
cl_int errcode = CL_SUCCESS;
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
const HRESULT hr = dx_device->CreateSharedHandle(
fence, nullptr, GENERIC_ALL, nullptr, &fence_handle);
test_error(FAILED(hr), "Failed to get shared handle from D3D12 fence");
cl_semaphore_properties_khr sem_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_TYPE_BINARY_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
reinterpret_cast<cl_semaphore_properties_khr>(fence_handle), 0
};
semaphore =
clCreateSemaphoreWithPropertiesKHR(context, sem_props, &errcode);
test_error(errcode, "Could not create semaphore");
return CL_SUCCESS;
}
~CLDXSemaphoreWrapper()
{
releaseSemaphore();
if (fence_handle)
{
CloseHandle(fence_handle);
fence_handle = nullptr;
}
};
const cl_semaphore_khr* operator&() const { return &semaphore; };
cl_semaphore_khr operator*() const { return semaphore; };
HANDLE getHandle() const { return fence_handle; };
private:
cl_semaphore_khr semaphore;
ComPtr<ID3D12Fence> fence;
HANDLE fence_handle;
cl_device_id device;
cl_context context;
ComPtr<ID3D12Device> dx_device;
int releaseSemaphore() const
if (fence_wrapper)
{
GET_PFN(device, clReleaseSemaphoreKHR);
delete fence_wrapper;
fence_wrapper = nullptr;
}
if (semaphore)
{
clReleaseSemaphoreKHR(semaphore);
semaphore = nullptr;
}
};
virtual int SetUp()
{
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_FUNCTION_EXTENSION_ADDRESS(device,
clCreateSemaphoreWithPropertiesKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clReleaseSemaphoreKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clEnqueueSignalSemaphoresKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clEnqueueWaitSemaphoresKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clGetSemaphoreHandleForTypeKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clRetainSemaphoreKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clGetSemaphoreInfoKHR);
test_error(
!is_import_handle_available(CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
fence_wrapper = new DirectXFenceWrapper(dx_wrapper.getDXDevice());
semaphore = createSemaphoreFromFence(fence_wrapper->get());
test_assert_error(!!semaphore, "Could not create semaphore");
return TEST_PASS;
}
return CL_SUCCESS;
}
};
virtual cl_int Run() = 0;
static bool
is_import_handle_available(cl_device_id device,
const cl_external_memory_handle_type_khr handle_type)
{
protected:
int errcode = CL_SUCCESS;
cl_device_id device = nullptr;
cl_context context = nullptr;
cl_command_queue queue = nullptr;
cl_int num_elems = 0;
DirectXWrapper dx_wrapper;
cl_semaphore_payload_khr semaphore_payload = 1;
cl_semaphore_khr semaphore = nullptr;
HANDLE fence_handle = nullptr;
DirectXFenceWrapper *fence_wrapper = nullptr;
clCreateSemaphoreWithPropertiesKHR_fn clCreateSemaphoreWithPropertiesKHR =
nullptr;
clEnqueueSignalSemaphoresKHR_fn clEnqueueSignalSemaphoresKHR = nullptr;
clEnqueueWaitSemaphoresKHR_fn clEnqueueWaitSemaphoresKHR = nullptr;
clReleaseSemaphoreKHR_fn clReleaseSemaphoreKHR = nullptr;
clGetSemaphoreInfoKHR_fn clGetSemaphoreInfoKHR = nullptr;
clRetainSemaphoreKHR_fn clRetainSemaphoreKHR = nullptr;
clGetSemaphoreHandleForTypeKHR_fn clGetSemaphoreHandleForTypeKHR = nullptr;
[[nodiscard]] bool is_import_handle_available(
const cl_external_memory_handle_type_khr handle_type)
{
size_t import_types_size = 0;
errcode =
clGetDeviceInfo(device, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR, 0,
nullptr, &import_types_size);
clGetDeviceInfo(device, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR,
0, nullptr, &import_types_size);
if (errcode != CL_SUCCESS)
{
log_error("Could not query import semaphore handle types");
@@ -114,4 +124,46 @@ is_import_handle_available(cl_device_id device,
return std::find(import_types.begin(), import_types.end(), handle_type)
!= import_types.end();
}
cl_semaphore_khr createSemaphoreFromFence(ID3D12Fence *src_fence)
{
const HRESULT hr = dx_wrapper.getDXDevice()->CreateSharedHandle(
src_fence, nullptr, GENERIC_ALL, nullptr, &fence_handle);
if (FAILED(hr)) return nullptr;
const cl_semaphore_properties_khr sem_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_TYPE_BINARY_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
reinterpret_cast<cl_semaphore_properties_khr>(fence_handle), 0
};
cl_semaphore_khr tmp_semaphore =
clCreateSemaphoreWithPropertiesKHR(context, sem_props, &errcode);
if (errcode != CL_SUCCESS) return nullptr;
return tmp_semaphore;
}
};
template <class T>
int MakeAndRunTest(cl_device_id device, cl_context context,
cl_command_queue queue, cl_int nelems)
{
cl_int status = TEST_PASS;
try
{
auto test_fixture = T(device, context, queue, nelems);
status = test_fixture.SetUp();
if (status != TEST_PASS) return status;
status = test_fixture.Run();
} catch (const std::runtime_error &e)
{
log_error("%s", e.what());
return TEST_FAIL;
}
return status;
}

286
test_conformance/extensions/cl_khr_external_semaphore_dx_fence/test_external_semaphore_dx_fence.cpp
View File

@@ -16,37 +16,17 @@
#include "semaphore_dx_fence_base.h"
// Confirm that a signal followed by a wait in OpenCL will complete successfully
REGISTER_TEST(test_external_semaphores_signal_wait)
struct SignalWait final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
cl_int Run() override
{
log_info("Calling clEnqueueSignalSemaphoresKHR\n");
constexpr cl_semaphore_payload_khr semaphore_payload = 1;
clEventWrapper signal_event;
errcode = clEnqueueSignalSemaphoresKHR(
queue, 1, &semaphore, &semaphore_payload, 0, nullptr, &signal_event);
errcode = clEnqueueSignalSemaphoresKHR(queue, 1, &semaphore,
&semaphore_payload, 0, nullptr,
&signal_event);
test_error(errcode, "Failed to signal semaphore");
log_info("Calling clEnqueueWaitSemaphoresKHR\n");
@@ -63,44 +43,29 @@ REGISTER_TEST(test_external_semaphores_signal_wait)
test_assert_event_complete(wait_event);
return TEST_PASS;
}
};
// Confirm that a signal followed by a wait in OpenCL will complete successfully
REGISTER_TEST(test_external_semaphores_signal_wait)
{
return MakeAndRunTest<SignalWait>(device, context, queue, num_elements);
}
// Confirm that a wait in OpenCL followed by a CPU signal in DX12 will complete
// successfully
REGISTER_TEST(test_external_semaphores_signal_dx_cpu)
struct SignalDXCPU final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
cl_int Run() override
{
log_info("Calling clEnqueueWaitSemaphoresKHR\n");
constexpr cl_semaphore_payload_khr semaphore_payload = 1;
clEventWrapper wait_event;
errcode = clEnqueueWaitSemaphoresKHR(
queue, 1, &semaphore, &semaphore_payload, 0, nullptr, &wait_event);
test_error(errcode, "Failed to call clEnqueueWaitSemaphoresKHR");
log_info("Calling d3d12_fence->Signal()\n");
const HRESULT hr = (*fence)->Signal(semaphore_payload);
const HRESULT hr = fence_wrapper->get()->Signal(semaphore_payload);
test_error(FAILED(hr), "Failed to signal D3D12 fence");
errcode = clFinish(queue);
@@ -109,45 +74,31 @@ REGISTER_TEST(test_external_semaphores_signal_dx_cpu)
test_assert_event_complete(wait_event);
return TEST_PASS;
}
};
// Confirm that a wait in OpenCL followed by a CPU signal in DX12 will complete
// successfully
REGISTER_TEST(test_external_semaphores_signal_dx_cpu)
{
return MakeAndRunTest<SignalDXCPU>(device, context, queue, num_elements);
}
// Confirm that a wait in OpenCL followed by a GPU signal in DX12 will complete
// successfully
REGISTER_TEST(test_external_semaphores_signal_dx_gpu)
struct SignalDXGPU final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
cl_int Run() override
{
log_info("Calling clEnqueueWaitSemaphoresKHR\n");
constexpr cl_semaphore_payload_khr semaphore_payload = 1;
clEventWrapper wait_event;
errcode = clEnqueueWaitSemaphoresKHR(
queue, 1, &semaphore, &semaphore_payload, 0, nullptr, &wait_event);
test_error(errcode, "Failed to call clEnqueueWaitSemaphoresKHR");
log_info("Calling d3d12_command_queue->Signal()\n");
const HRESULT hr =
dx_wrapper.getDXCommandQueue()->Signal(*fence, semaphore_payload);
const HRESULT hr = dx_wrapper.getDXCommandQueue()->Signal(
fence_wrapper->get(), semaphore_payload);
test_error(FAILED(hr), "Failed to signal D3D12 fence");
errcode = clFinish(queue);
@@ -156,49 +107,37 @@ REGISTER_TEST(test_external_semaphores_signal_dx_gpu)
test_assert_event_complete(wait_event);
return TEST_PASS;
}
};
// Confirm that a wait in OpenCL followed by a GPU signal in DX12 will complete
// successfully
REGISTER_TEST(test_external_semaphores_signal_dx_gpu)
{
return MakeAndRunTest<SignalDXGPU>(device, context, queue, num_elements);
}
// Confirm that interlocking waits between OpenCL and DX12 will complete
// successfully
REGISTER_TEST(test_external_semaphores_cl_dx_interlock)
struct CLDXInterlock final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
cl_int Run() override
{
log_info("Calling d3d12_command_queue->Wait(1)\n");
cl_semaphore_payload_khr semaphore_payload = 1;
HRESULT hr =
dx_wrapper.getDXCommandQueue()->Wait(*fence, semaphore_payload);
HRESULT hr = dx_wrapper.getDXCommandQueue()->Wait(fence_wrapper->get(),
semaphore_payload);
test_error(FAILED(hr), "Failed to wait on D3D12 fence");
log_info("Calling d3d12_command_queue->Signal(2)\n");
hr = dx_wrapper.getDXCommandQueue()->Signal(*fence, semaphore_payload + 1);
hr = dx_wrapper.getDXCommandQueue()->Signal(fence_wrapper->get(),
semaphore_payload + 1);
test_error(FAILED(hr), "Failed to signal D3D12 fence");
log_info("Calling clEnqueueSignalSemaphoresKHR(1)\n");
clEventWrapper signal_event;
errcode = clEnqueueSignalSemaphoresKHR(
queue, 1, &semaphore, &semaphore_payload, 0, nullptr, &signal_event);
errcode = clEnqueueSignalSemaphoresKHR(queue, 1, &semaphore,
&semaphore_payload, 0, nullptr,
&signal_event);
test_error(errcode, "Failed to call clEnqueueSignalSemaphoresKHR");
log_info("Calling clEnqueueWaitSemaphoresKHR(2)\n");
@@ -215,42 +154,53 @@ REGISTER_TEST(test_external_semaphores_cl_dx_interlock)
test_assert_event_complete(signal_event);
return TEST_PASS;
}
};
// Confirm that interlocking waits between OpenCL and DX12 will complete
// successfully
REGISTER_TEST(test_external_semaphores_cl_dx_interlock)
{
return MakeAndRunTest<CLDXInterlock>(device, context, queue, num_elements);
}
// Confirm that multiple waits in OpenCL followed by signals in DX12 and waits
// in DX12 followed by signals in OpenCL complete successfully
REGISTER_TEST(test_external_semaphores_multiple_wait_signal)
struct MultipleWaitSignal final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
using DXFenceTestBase::DXFenceTestBase;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
~MultipleWaitSignal() override
{
if (fence_handle_2)
{
CloseHandle(fence_handle_2);
fence_handle_2 = nullptr;
}
if (fence_wrapper_2)
{
delete fence_wrapper_2;
fence_wrapper_2 = nullptr;
}
if (semaphore_2)
{
clReleaseSemaphoreKHR(semaphore_2);
semaphore_2 = nullptr;
}
DXFenceTestBase::~DXFenceTestBase();
};
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
int SetUp() override
{
DXFenceTestBase::SetUp();
fence_wrapper_2 = new DirectXFenceWrapper(dx_wrapper.getDXDevice());
semaphore_2 = createSemaphoreFromFence(fence_wrapper_2->get());
test_assert_error(!!semaphore_2, "Could not create semaphore");
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
return TEST_PASS;
}
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence_1(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore_1(device, context, dx_wrapper.getDXDevice());
test_error(semaphore_1.createSemaphoreFromFence(*fence_1),
"Could not create semaphore");
const DirectXFenceWrapper fence_2(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore_2(device, context, dx_wrapper.getDXDevice());
test_error(semaphore_2.createSemaphoreFromFence(*fence_2),
"Could not create semaphore");
const cl_semaphore_khr semaphore_list[] = { *semaphore_1, *semaphore_2 };
constexpr cl_semaphore_payload_khr semaphore_payload = 1;
cl_int Run() override
{
const cl_semaphore_khr semaphore_list[] = { semaphore, semaphore_2 };
cl_semaphore_payload_khr semaphore_payload_list[] = {
semaphore_payload, semaphore_payload + 1
};
@@ -263,16 +213,20 @@ REGISTER_TEST(test_external_semaphores_multiple_wait_signal)
test_error(errcode, "Failed to call clEnqueueWaitSemaphoresKHR");
log_info("Calling d3d12_command_queue->Signal()\n");
HRESULT hr =
dx_wrapper.getDXCommandQueue()->Signal(*fence_2, semaphore_payload + 1);
HRESULT hr = dx_wrapper.getDXCommandQueue()->Signal(
fence_wrapper_2->get(), semaphore_payload + 1);
test_error(FAILED(hr), "Failed to signal D3D12 fence 2");
hr = dx_wrapper.getDXCommandQueue()->Signal(*fence_1, semaphore_payload);
hr = dx_wrapper.getDXCommandQueue()->Signal(fence_wrapper->get(),
semaphore_payload);
test_error(FAILED(hr), "Failed to signal D3D12 fence 1");
log_info("Calling d3d12_command_queue->Wait() with different payloads\n");
hr = dx_wrapper.getDXCommandQueue()->Wait(*fence_1, semaphore_payload + 3);
log_info(
"Calling d3d12_command_queue->Wait() with different payloads\n");
hr = dx_wrapper.getDXCommandQueue()->Wait(fence_wrapper->get(),
semaphore_payload + 3);
test_error(FAILED(hr), "Failed to wait on D3D12 fence 1");
hr = dx_wrapper.getDXCommandQueue()->Wait(*fence_2, semaphore_payload + 2);
hr = dx_wrapper.getDXCommandQueue()->Wait(fence_wrapper_2->get(),
semaphore_payload + 2);
test_error(FAILED(hr), "Failed to wait on D3D12 fence 2");
errcode = clFinish(queue);
@@ -286,29 +240,31 @@ REGISTER_TEST(test_external_semaphores_multiple_wait_signal)
log_info("Calling clEnqueueSignalSemaphoresKHR\n");
clEventWrapper signal_event;
errcode = clEnqueueSignalSemaphoresKHR(queue, 2, semaphore_list,
semaphore_payload_list, 0, nullptr,
&signal_event);
semaphore_payload_list, 0,
nullptr, &signal_event);
test_error(errcode, "Could not call clEnqueueSignalSemaphoresKHR");
// Wait until the GPU has completed commands up to this fence point.
log_info("Waiting for D3D12 command queue completion\n");
if ((*fence_1)->GetCompletedValue() < semaphore_payload_list[0])
if (fence_wrapper->get()->GetCompletedValue()
< semaphore_payload_list[0])
{
const HANDLE event_handle =
CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
hr = (*fence_1)->SetEventOnCompletion(semaphore_payload_list[0],
event_handle);
CreateEventEx(nullptr, nullptr, false, EVENT_ALL_ACCESS);
hr = fence_wrapper->get()->SetEventOnCompletion(
semaphore_payload_list[0], event_handle);
test_error(FAILED(hr),
"Failed to set D3D12 fence 1 event on completion");
WaitForSingleObject(event_handle, INFINITE);
CloseHandle(event_handle);
}
if ((*fence_2)->GetCompletedValue() < semaphore_payload_list[1])
if (fence_wrapper_2->get()->GetCompletedValue()
< semaphore_payload_list[1])
{
const HANDLE event_handle =
CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
hr = (*fence_2)->SetEventOnCompletion(semaphore_payload_list[1],
event_handle);
CreateEventEx(nullptr, nullptr, false, EVENT_ALL_ACCESS);
hr = fence_wrapper_2->get()->SetEventOnCompletion(
semaphore_payload_list[1], event_handle);
test_error(FAILED(hr),
"Failed to set D3D12 fence 2 event on completion");
WaitForSingleObject(event_handle, INFINITE);
@@ -321,4 +277,18 @@ REGISTER_TEST(test_external_semaphores_multiple_wait_signal)
test_assert_event_complete(signal_event);
return TEST_PASS;
}
protected:
cl_semaphore_khr semaphore_2 = nullptr;
HANDLE fence_handle_2 = nullptr;
DirectXFenceWrapper *fence_wrapper_2 = nullptr;
};
// Confirm that multiple waits in OpenCL followed by signals in DX12 and waits
// in DX12 followed by signals in OpenCL complete successfully
REGISTER_TEST(test_external_semaphores_multiple_wait_signal)
{
return MakeAndRunTest<MultipleWaitSignal>(device, context, queue,
num_elements);
}

136
test_conformance/extensions/cl_khr_external_semaphore_dx_fence/test_external_semaphore_dx_fence_export.cpp
View File

@@ -16,28 +16,16 @@
#include "semaphore_dx_fence_base.h"
// Confirm that a wait followed by a signal in DirectX 12 using an exported
// semaphore will complete successfully
REGISTER_TEST(test_external_semaphores_export_dx_signal)
struct ExportDXSignal final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
GET_PFN(device, clGetSemaphoreInfoKHR);
GET_PFN(device, clGetSemaphoreHandleForTypeKHR);
using DXFenceTestBase::DXFenceTestBase;
int Run() override
{
size_t export_types_size = 0;
errcode =
clGetDeviceInfo(device, CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, 0,
nullptr, &export_types_size);
clGetDeviceInfo(device, CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR,
0, nullptr, &export_types_size);
test_error(errcode, "Could not query export semaphore handle types");
std::vector<cl_external_semaphore_handle_type_khr> export_types(
export_types_size / sizeof(cl_external_semaphore_handle_type_khr));
@@ -50,14 +38,16 @@ REGISTER_TEST(test_external_semaphores_export_dx_signal)
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR)
== export_types.end())
{
log_info("Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between "
log_info(
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between "
"the supported export types\n");
return TEST_FAIL;
}
constexpr cl_semaphore_properties_khr sem_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_BINARY_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_TYPE_BINARY_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR),
static_cast<cl_semaphore_properties_khr>(
@@ -66,37 +56,37 @@ REGISTER_TEST(test_external_semaphores_export_dx_signal)
CL_SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR),
0
};
cl_semaphore_khr semaphore =
cl_semaphore_khr exportable_semaphore =
clCreateSemaphoreWithPropertiesKHR(context, sem_props, &errcode);
test_error(errcode, "Could not create semaphore");
cl_bool is_exportable = CL_FALSE;
errcode =
clGetSemaphoreInfoKHR(semaphore, CL_SEMAPHORE_EXPORTABLE_KHR,
errcode = clGetSemaphoreInfoKHR(
exportable_semaphore, CL_SEMAPHORE_EXPORTABLE_KHR,
sizeof(is_exportable), &is_exportable, nullptr);
test_error(errcode, "Could not get semaphore info");
test_error(!is_exportable, "Semaphore is not exportable");
log_info("Calling clEnqueueWaitSemaphoresKHR\n");
constexpr cl_semaphore_payload_khr semaphore_payload = 1;
clEventWrapper wait_event;
errcode = clEnqueueWaitSemaphoresKHR(
queue, 1, &semaphore, &semaphore_payload, 0, nullptr, &wait_event);
errcode = clEnqueueWaitSemaphoresKHR(queue, 1, &exportable_semaphore,
&semaphore_payload, 0, nullptr,
&wait_event);
test_error(errcode, "Failed to wait semaphore");
HANDLE semaphore_handle = nullptr;
errcode = clGetSemaphoreHandleForTypeKHR(
semaphore, device, CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR,
exportable_semaphore, device, CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR,
sizeof(semaphore_handle), &semaphore_handle, nullptr);
test_error(errcode, "Could not get semaphore handle");
ID3D12Fence *fence = nullptr;
errcode = dx_wrapper.getDXDevice()->OpenSharedHandle(semaphore_handle,
IID_PPV_ARGS(&fence));
ID3D12Fence *exported_fence = nullptr;
errcode = dx_wrapper.getDXDevice()->OpenSharedHandle(
semaphore_handle, IID_PPV_ARGS(&exported_fence));
test_error(errcode, "Could not open semaphore handle");
log_info("Calling fence->Signal()\n");
const HRESULT hr = fence->Signal(semaphore_payload);
const HRESULT hr = exported_fence->Signal(semaphore_payload);
test_error(FAILED(hr), "Failed to signal D3D12 fence");
errcode = clFinish(queue);
@@ -106,34 +96,31 @@ REGISTER_TEST(test_external_semaphores_export_dx_signal)
// Release resources
CloseHandle(semaphore_handle);
test_error(clReleaseSemaphoreKHR(semaphore), "Could not release semaphore");
fence->Release();
test_error(clReleaseSemaphoreKHR(exportable_semaphore),
"Could not release semaphore");
exported_fence->Release();
return TEST_PASS;
}
};
// Confirm that a wait followed by a signal in DirectX 12 using an exported
// semaphore will complete successfully
REGISTER_TEST(test_external_semaphores_export_dx_signal)
{
return MakeAndRunTest<ExportDXSignal>(device, context, queue, num_elements);
}
// Confirm that a signal in OpenCL followed by a wait in DirectX 12 using an
// exported semaphore will complete successfully
REGISTER_TEST(test_external_semaphores_export_dx_wait)
struct ExportDXWait final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
GET_PFN(device, clGetSemaphoreInfoKHR);
GET_PFN(device, clGetSemaphoreHandleForTypeKHR);
using DXFenceTestBase::DXFenceTestBase;
int Run() override
{
size_t export_types_size = 0;
errcode =
clGetDeviceInfo(device, CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, 0,
nullptr, &export_types_size);
clGetDeviceInfo(device, CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR,
0, nullptr, &export_types_size);
test_error(errcode, "Could not query export semaphore handle types");
std::vector<cl_external_semaphore_handle_type_khr> export_types(
export_types_size / sizeof(cl_external_semaphore_handle_type_khr));
@@ -146,14 +133,16 @@ REGISTER_TEST(test_external_semaphores_export_dx_wait)
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR)
== export_types.end())
{
log_info("Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between "
log_info(
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between "
"the supported export types\n");
return TEST_FAIL;
}
constexpr cl_semaphore_properties_khr sem_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_BINARY_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_TYPE_BINARY_KHR),
static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR),
static_cast<cl_semaphore_properties_khr>(
@@ -162,13 +151,13 @@ REGISTER_TEST(test_external_semaphores_export_dx_wait)
CL_SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR),
0
};
cl_semaphore_khr semaphore =
cl_semaphore_khr exportable_semaphore =
clCreateSemaphoreWithPropertiesKHR(context, sem_props, &errcode);
test_error(errcode, "Could not create semaphore");
cl_bool is_exportable = CL_FALSE;
errcode =
clGetSemaphoreInfoKHR(semaphore, CL_SEMAPHORE_EXPORTABLE_KHR,
errcode = clGetSemaphoreInfoKHR(
exportable_semaphore, CL_SEMAPHORE_EXPORTABLE_KHR,
sizeof(is_exportable), &is_exportable, nullptr);
test_error(errcode, "Could not get semaphore info");
test_error(!is_exportable, "Semaphore is not exportable");
@@ -176,31 +165,33 @@ REGISTER_TEST(test_external_semaphores_export_dx_wait)
log_info("Calling clEnqueueSignalSemaphoresKHR\n");
constexpr cl_semaphore_payload_khr semaphore_payload = 1;
clEventWrapper signal_event;
errcode = clEnqueueSignalSemaphoresKHR(
queue, 1, &semaphore, &semaphore_payload, 0, nullptr, &signal_event);
errcode = clEnqueueSignalSemaphoresKHR(queue, 1, &exportable_semaphore,
&semaphore_payload, 0, nullptr,
&signal_event);
test_error(errcode, "Failed to signal semaphore");
HANDLE semaphore_handle = nullptr;
errcode = clGetSemaphoreHandleForTypeKHR(
semaphore, device, CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR,
exportable_semaphore, device, CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR,
sizeof(semaphore_handle), &semaphore_handle, nullptr);
test_error(errcode, "Could not get semaphore handle");
ID3D12Fence *fence = nullptr;
errcode = dx_wrapper.getDXDevice()->OpenSharedHandle(semaphore_handle,
IID_PPV_ARGS(&fence));
ID3D12Fence *exported_fence = nullptr;
errcode = dx_wrapper.getDXDevice()->OpenSharedHandle(
semaphore_handle, IID_PPV_ARGS(&exported_fence));
test_error(errcode, "Could not open semaphore handle");
log_info("Calling dx_wrapper.get_d3d12_command_queue()->Wait()\n");
HRESULT hr = dx_wrapper.getDXCommandQueue()->Wait(fence, semaphore_payload);
HRESULT hr = dx_wrapper.getDXCommandQueue()->Wait(exported_fence,
semaphore_payload);
test_error(FAILED(hr), "Failed to wait on D3D12 fence");
log_info("Calling WaitForSingleObject\n");
if (fence->GetCompletedValue() < semaphore_payload)
if (exported_fence->GetCompletedValue() < semaphore_payload)
{
const HANDLE event =
CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
hr = fence->SetEventOnCompletion(semaphore_payload, event);
CreateEventEx(nullptr, nullptr, false, EVENT_ALL_ACCESS);
hr = exported_fence->SetEventOnCompletion(semaphore_payload, event);
test_error(FAILED(hr), "Failed to set event on completion");
WaitForSingleObject(event, INFINITE);
CloseHandle(event);
@@ -213,8 +204,17 @@ REGISTER_TEST(test_external_semaphores_export_dx_wait)
// Release resources
CloseHandle(semaphore_handle);
test_error(clReleaseSemaphoreKHR(semaphore), "Could not release semaphore");
fence->Release();
test_error(clReleaseSemaphoreKHR(exportable_semaphore),
"Could not release semaphore");
exported_fence->Release();
return TEST_PASS;
}
};
// Confirm that a signal in OpenCL followed by a wait in DirectX 12 using an
// exported semaphore will complete successfully
REGISTER_TEST(test_external_semaphores_export_dx_wait)
{
return MakeAndRunTest<ExportDXWait>(device, context, queue, num_elements);
}

74
test_conformance/extensions/cl_khr_external_semaphore_dx_fence/test_external_semaphore_dx_fence_negative_wait_signal.cpp
View File

@@ -16,32 +16,12 @@
#include "semaphore_dx_fence_base.h"
// Confirm that a wait without a semaphore payload list will return
// CL_INVALID_VALUE
REGISTER_TEST(test_external_semaphores_dx_fence_negative_wait)
struct DXFenceNegativeWait final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueWaitSemaphoresKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
int Run() override
{
log_info("Calling clEnqueueWaitSemaphoresKHR\n");
errcode = clEnqueueWaitSemaphoresKHR(queue, 1, &semaphore, nullptr, 0,
nullptr, nullptr);
@@ -50,34 +30,23 @@ REGISTER_TEST(test_external_semaphores_dx_fence_negative_wait)
"Unexpected error code returned from clEnqueueWaitSemaphores");
return TEST_PASS;
}
};
// Confirm that a wait without a semaphore payload list will return
// CL_INVALID_VALUE
REGISTER_TEST(test_external_semaphores_dx_fence_negative_wait)
{
return MakeAndRunTest<DXFenceNegativeWait>(device, context, queue,
num_elements);
}
// Confirm that a signal without a semaphore payload list will return
// CL_INVALID_VALUE
REGISTER_TEST(test_external_semaphores_dx_fence_negative_signal)
struct DXFenceNegativeSignal final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clEnqueueSignalSemaphoresKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
int Run() override
{
log_info("Calling clEnqueueWaitSemaphoresKHR\n");
errcode = clEnqueueSignalSemaphoresKHR(queue, 1, &semaphore, nullptr, 0,
nullptr, nullptr);
@@ -86,4 +55,13 @@ REGISTER_TEST(test_external_semaphores_dx_fence_negative_signal)
"Unexpected error code returned from clEnqueueSignalSemaphores");
return TEST_PASS;
}
};
// Confirm that a signal without a semaphore payload list will return
// CL_INVALID_VALUE
REGISTER_TEST(test_external_semaphores_dx_fence_negative_signal)
{
return MakeAndRunTest<DXFenceNegativeSignal>(device, context, queue,
num_elements);
}

49
test_conformance/extensions/cl_khr_external_semaphore_dx_fence/test_external_semaphore_dx_fence_queries.cpp
View File

@@ -16,39 +16,19 @@
#include "semaphore_dx_fence_base.h"
// Confirm that the CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR property is in the
// properties returned by clGetSemaphoreInfo
REGISTER_TEST(test_external_semaphores_dx_fence_query_properties)
struct DXFenceQueryProperties final : DXFenceTestBase
{
int errcode = CL_SUCCESS;
const DirectXWrapper dx_wrapper;
REQUIRE_EXTENSION("cl_khr_external_semaphore");
REQUIRE_EXTENSION("cl_khr_external_semaphore_dx_fence");
// Obtain pointers to semaphore's API
GET_PFN(device, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(device, clReleaseSemaphoreKHR);
GET_PFN(device, clGetSemaphoreInfoKHR);
test_error(!is_import_handle_available(device,
CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR),
"Could not find CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR between the "
"supported import types");
// Import D3D12 fence into OpenCL
const DirectXFenceWrapper fence(dx_wrapper.getDXDevice());
CLDXSemaphoreWrapper semaphore(device, context, dx_wrapper.getDXDevice());
test_error(semaphore.createSemaphoreFromFence(*fence),
"Could not create semaphore");
using DXFenceTestBase::DXFenceTestBase;
int Run() override
{
size_t properties_size_bytes = 0;
errcode = clGetSemaphoreInfoKHR(*semaphore, CL_SEMAPHORE_PROPERTIES_KHR, 0,
nullptr, &properties_size_bytes);
errcode = clGetSemaphoreInfoKHR(semaphore, CL_SEMAPHORE_PROPERTIES_KHR,
0, nullptr, &properties_size_bytes);
test_error(errcode, "Could not get semaphore info");
std::vector<cl_semaphore_properties_khr> semaphore_properties(
properties_size_bytes / sizeof(cl_semaphore_properties_khr));
errcode = clGetSemaphoreInfoKHR(*semaphore, CL_SEMAPHORE_PROPERTIES_KHR,
errcode = clGetSemaphoreInfoKHR(semaphore, CL_SEMAPHORE_PROPERTIES_KHR,
properties_size_bytes,
semaphore_properties.data(), nullptr);
test_error(errcode, "Could not get semaphore info");
@@ -58,12 +38,21 @@ REGISTER_TEST(test_external_semaphores_dx_fence_query_properties)
if (semaphore_properties[i] == CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR
&& semaphore_properties[i + 1]
== reinterpret_cast<cl_semaphore_properties_khr>(
semaphore.getHandle()))
fence_handle))
{
return TEST_PASS;
}
}
log_error(
"Failed to find the dx fence handle type in the semaphore properties");
log_error("Failed to find the dx fence handle type in the semaphore "
"properties");
return TEST_FAIL;
}
};
// Confirm that the CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR property is in the
// properties returned by clGetSemaphoreInfo
REGISTER_TEST(test_external_semaphores_dx_fence_query_properties)
{
return MakeAndRunTest<DXFenceQueryProperties>(device, context, queue,
num_elements);
}

29
test_conformance/extensions/cl_khr_semaphore/semaphore_base.h
View File

@@ -23,6 +23,7 @@
#include "harness/deviceInfo.h"
#include "harness/testHarness.h"
#include "harness/typeWrappers.h"
#include "harness/extensionHelpers.h"
struct SemaphoreBase
{
@@ -37,27 +38,15 @@ struct SemaphoreBase
test_error(error, "clGetDeviceInfo for CL_DEVICE_PLATFORM failed");
// If it is supported get the addresses of all the APIs here.
// clang-format off
#define GET_EXTENSION_ADDRESS(FUNC) \
FUNC = reinterpret_cast<FUNC##_fn>( \
clGetExtensionFunctionAddressForPlatform(platform, #FUNC)); \
if (FUNC == nullptr) \
{ \
log_error("ERROR: clGetExtensionFunctionAddressForPlatform failed" \
" with " #FUNC "\n"); \
return TEST_FAIL; \
}
// clang-format on
GET_FUNCTION_EXTENSION_ADDRESS(device,
clCreateSemaphoreWithPropertiesKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clEnqueueSignalSemaphoresKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clEnqueueWaitSemaphoresKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clReleaseSemaphoreKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clGetSemaphoreInfoKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clRetainSemaphoreKHR);
GET_FUNCTION_EXTENSION_ADDRESS(device, clGetSemaphoreHandleForTypeKHR);
GET_EXTENSION_ADDRESS(clCreateSemaphoreWithPropertiesKHR);
GET_EXTENSION_ADDRESS(clEnqueueSignalSemaphoresKHR);
GET_EXTENSION_ADDRESS(clEnqueueWaitSemaphoresKHR);
GET_EXTENSION_ADDRESS(clReleaseSemaphoreKHR);
GET_EXTENSION_ADDRESS(clGetSemaphoreInfoKHR);
GET_EXTENSION_ADDRESS(clRetainSemaphoreKHR);
GET_EXTENSION_ADDRESS(clGetSemaphoreHandleForTypeKHR);
#undef GET_EXTENSION_ADDRESS
return CL_SUCCESS;
}