ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor external semaphore scaffolding (#2300)

Browse Source 
Remove the `CREATE_OPENCL_SEMAPHORE` macro and use derived class
instantiations of the `clExternalSemaphore` class, rather than base
pointers to derived class objects.

Remove the default argument for `queryParamName` in
`check_external_semaphore_handle_type()`.

Move `check_external_semaphore_handle_type()` checks to constructors of
`clExternalImportableSemaphore` and `clExternalExportableSemaphore`,
rather than manually making the check before creating an external
semaphore.

---------

Signed-off-by: Gorazd Sumkovski <gorazd.sumkovski@arm.com>
Co-authored-by: Kévin Petit <kpet@free.fr>
Co-authored-by: Kevin Petit <kevin.petit@arm.com>
This commit is contained in:
gorazd-sumkovski-arm
2025-04-16 04:41:38 +01:00
committed by GitHub
parent 4ce3d8968a
commit 33846e6673
6 changed files with 148 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -529,8 +529,8 @@ cl_int check_external_memory_handle_type(
return CL_INVALID_VALUE;
}
cl_int check_external_semaphore_handle_type(
cl_device_id deviceID,
void check_external_semaphore_handle_type(
cl_device_id device,
cl_external_semaphore_handle_type_khr requiredHandleType,
cl_device_info queryParamName)
{
@@ -540,8 +540,8 @@ cl_int check_external_semaphore_handle_type(
cl_int errNum = CL_SUCCESS;
errNum =
clGetDeviceInfo(deviceID, queryParamName, 0, NULL, &handle_type_size);
test_error(errNum, "clGetDeviceInfo failed");
clGetDeviceInfo(device, queryParamName, 0, NULL, &handle_type_size);
ASSERT_SUCCESS(errNum, "clGetDeviceInfo");
if (handle_type_size == 0)
{
@@ -549,31 +549,37 @@ cl_int check_external_semaphore_handle_type(
queryParamName == CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR
? "importing"
: "exporting");
return CL_INVALID_VALUE;
throw std::runtime_error("");
}
handle_type =
(cl_external_semaphore_handle_type_khr *)malloc(handle_type_size);
errNum = clGetDeviceInfo(deviceID, queryParamName, handle_type_size,
errNum = clGetDeviceInfo(device, queryParamName, handle_type_size,
handle_type, NULL);
ASSERT_SUCCESS(errNum, "clGetDeviceInfo");
test_error(
errNum,
"Unable to query supported device semaphore handle types list\n");
bool found = false;
for (i = 0; i < handle_type_size; i++)
{
if (requiredHandleType == handle_type[i])
{
return CL_SUCCESS;
found = true;
break;
}
}
log_error("cl_khr_external_semaphore extension is missing support for %d\n",
requiredHandleType);
return CL_INVALID_VALUE;
if (!found)
{
log_error("cl_khr_external_semaphore extension is missing support for "
"handle type %d\n",
requiredHandleType);
throw std::runtime_error("");
}
}
clExternalMemory::clExternalMemory() {}
clExternalMemory::clExternalMemory(const clExternalMemory &externalMemory)
@@ -859,9 +865,15 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
cl_device_id deviceId)
: m_deviceSemaphore(semaphore)
{
cl_int err = 0;
cl_device_id devList[] = { deviceId, NULL };
cl_external_semaphore_handle_type_khr clSemaphoreHandleType =
getCLSemaphoreTypeFromVulkanType(externalSemaphoreHandleType);
check_external_semaphore_handle_type(
deviceId, clSemaphoreHandleType,
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
m_externalHandleType = externalSemaphoreHandleType;
m_externalSemaphore = nullptr;
m_device = deviceId;
@@ -879,8 +891,6 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
ASSERT(0);
#else
fd = (int)semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props.push_back(
(cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
sema_props.push_back((cl_semaphore_properties_khr)fd);
@@ -892,8 +902,6 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
ASSERT(0);
#else
handle = semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
sema_props.push_back((cl_semaphore_properties_khr)handle);
@@ -907,8 +915,6 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
const std::wstring &name = semaphore.getName();
if (name.size())
{
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_NAME_KHR);
sema_props.push_back(
(cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_NAME_KHR);
@@ -928,21 +934,17 @@ clExternalImportableSemaphore::clExternalImportableSemaphore(
ASSERT(0);
#else
handle = semaphore.getHandle(externalSemaphoreHandleType);
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props.push_back((cl_semaphore_properties_khr)
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
sema_props.push_back((cl_semaphore_properties_khr)handle);
#endif
break;
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
err = check_external_semaphore_handle_type(
devList[0], CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
sema_props.push_back(static_cast<cl_semaphore_properties_khr>(
CL_SEMAPHORE_HANDLE_SYNC_FD_KHR));
sema_props.push_back(static_cast<cl_semaphore_properties_khr>(-1));
break;
default:
log_error("Unsupported external memory handle type\n");
ASSERT(0);
@@ -1017,11 +1019,15 @@ clExternalExportableSemaphore::clExternalExportableSemaphore(
cl_device_id deviceId)
: m_deviceSemaphore(semaphore)
{
cl_int err = 0;
cl_device_id devList[] = { deviceId, NULL };
cl_external_semaphore_handle_type_khr clSemaphoreHandleType =
getCLSemaphoreTypeFromVulkanType(externalSemaphoreHandleType);
check_external_semaphore_handle_type(
deviceId, clSemaphoreHandleType,
CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR);
m_externalHandleType = externalSemaphoreHandleType;
m_externalSemaphore = nullptr;
m_device = deviceId;

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

@@ -28,23 +28,6 @@
#include <optional>
#define CREATE_OPENCL_SEMAPHORE(clSemaphore, vkSemaphore, ctx, handleType, \
devIdx, createExportable) \
if (!(createExportable \
&& (check_external_semaphore_handle_type( \
devIdx, getCLSemaphoreTypeFromVulkanType(handleType), \
CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR) \
== CL_SUCCESS))) \
{ \
clSemaphore = new clExternalImportableSemaphore(vkSemaphore, ctx, \
handleType, devIdx); \
} \
else \
{ \
clSemaphore = new clExternalExportableSemaphore(vkSemaphore, ctx, \
handleType, devIdx); \
}
typedef cl_semaphore_khr (*pfnclCreateSemaphoreWithPropertiesKHR)(
cl_context context, cl_semaphore_properties_khr *sema_props,
cl_int *errcode_ret);
@@ -93,11 +76,10 @@ cl_int getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *, size_t,
cl_int check_external_memory_handle_type(
cl_device_id deviceID,
cl_external_memory_handle_type_khr requiredHandleType);
cl_int check_external_semaphore_handle_type(
cl_device_id deviceID,
void check_external_semaphore_handle_type(
cl_device_id device,
cl_external_semaphore_handle_type_khr requiredHandleType,
cl_device_info queryParamName =
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
cl_device_info queryParamName);
cl_int setMaxImageDimensions(cl_device_id deviceID, size_t &width,
size_t &height);