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

Semaphore types bug fixes revised (#1822)

Browse Source 
* Added support for SYNC_FD and other handle types

* Fix consistency test

Deleted test cases that are no longer testable
according to the spec.

* Fix multi-import tests

-Delete obsolete code relating to offsets
-Propagate dedicated memory change

* Fix error handling

Some subtests did not fail on incorrect result.
Changes to macros to fail, so this does not occur
again.

* Delete invalid test cases

Test cases are not related to this extension.

* External memory test

Add support for any handle type supported by
the platform.

Change-Id: I6765fde5e7929988f49bfbf2df2f41d5263b6abc

* Update multi-import tests to use new semaphore types

* Fix formatting

* Addressed review comments. Deleted VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT as it appears to be redundant.
This commit is contained in:
joshqti
2023-11-29 02:32:59 -08:00
committed by GitHub
parent 5815e2ce33
commit f5bd92b83e
16 changed files with 1542 additions and 1451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -24,6 +24,7 @@
#include <algorithm>
#include <CL/cl.h>
#include <CL/cl_ext.h>
#include "deviceInfo.h"
#if defined(_WIN32) || defined(_WIN64)
#include <versionhelpers.h>
#endif
@@ -174,7 +175,7 @@ getVulkanMemoryType(const VulkanDevice &device,
}
}
// CHECK_LT(mtIdx, memoryTypeList.size());
ASSERT(mtIdx < memoryTypeList.size());
return memoryTypeList[mtIdx];
}
@@ -236,30 +237,112 @@ getSupportedVulkanExternalMemoryHandleTypeList()
}
const std::vector<VulkanExternalSemaphoreHandleType>
getSupportedVulkanExternalSemaphoreHandleTypeList()
getSupportedVulkanExternalSemaphoreHandleTypeList(const VulkanDevice &vkDevice)
{
typedef struct
{
const char *extension_name;
VkExternalSemaphoreHandleTypeFlagBits vk_type;
VulkanExternalSemaphoreHandleType enum_type;
} VkSemaphoreHandleMap;
// Add all known handle types, use Vulkan queries to determine what is
// supported.
std::vector<VkSemaphoreHandleMap> all_known_handle_types;
all_known_handle_types.push_back(
{ "VK_KHR_external_semaphore_fd",
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD });
all_known_handle_types.push_back(
{ "VK_KHR_external_semaphore_fd",
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD });
all_known_handle_types.push_back(
{ "VK_KHR_external_semaphore_win32",
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT });
all_known_handle_types.push_back(
{ "VK_KHR_external_semaphore_win32",
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT });
std::vector<VulkanExternalSemaphoreHandleType>
externalSemaphoreHandleTypeList;
#if _WIN32
if (IsWindows8OrGreater())
for (auto handle_type : all_known_handle_types)
{
externalSemaphoreHandleTypeList.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT);
if (!vkDevice.getPhysicalDevice().hasExtension(
handle_type.extension_name))
{
continue;
}
VkPhysicalDeviceExternalSemaphoreInfo handle_query = {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, nullptr,
handle_type.vk_type
};
VkExternalSemaphoreProperties query_result = {};
vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
vkDevice.getPhysicalDevice(), &handle_query, &query_result);
if (query_result.externalSemaphoreFeatures
& (VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR
| VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR))
{
externalSemaphoreHandleTypeList.push_back(handle_type.enum_type);
}
}
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);
#endif
return externalSemaphoreHandleTypeList;
}
std::vector<VulkanExternalSemaphoreHandleType>
getSupportedInteropExternalSemaphoreHandleTypes(cl_device_id device,
VulkanDevice &vkDevice)
{
const std::vector<VulkanExternalSemaphoreHandleType>
supportedVkSemaphoreTypes =
getSupportedVulkanExternalSemaphoreHandleTypeList(vkDevice);
std::vector<VulkanExternalSemaphoreHandleType> supportedSemaphoreTypes;
if (is_extension_available(device, "cl_khr_external_semaphore_opaque_fd")
&& std::count(supportedVkSemaphoreTypes.begin(),
supportedVkSemaphoreTypes.end(),
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD))
{
supportedSemaphoreTypes.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD);
}
if (is_extension_available(device, "cl_khr_external_semaphore_sync_fd")
&& std::count(supportedVkSemaphoreTypes.begin(),
supportedVkSemaphoreTypes.end(),
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD))
{
supportedSemaphoreTypes.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD);
}
if (is_extension_available(device, "cl_khr_external_semaphore_win32")
&& std::count(supportedVkSemaphoreTypes.begin(),
supportedVkSemaphoreTypes.end(),
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT))
{
supportedSemaphoreTypes.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT);
}
if (is_extension_available(device, "cl_khr_external_semaphore_win32")
&& std::count(supportedVkSemaphoreTypes.begin(),
supportedVkSemaphoreTypes.end(),
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT))
{
supportedSemaphoreTypes.push_back(
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT);
}
return supportedSemaphoreTypes;
}
const std::vector<VulkanFormat> getSupportedVulkanFormatList()
{
std::vector<VulkanFormat> formatList;
@@ -498,7 +581,6 @@ cl_external_semaphore_handle_type_khr getCLSemaphoreTypeFromVulkanType(
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;
@@ -631,8 +713,8 @@ operator<<(std::ostream &os,
return os << "Opaque NT handle";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
return os << "Opaque D3DKMT handle";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
return os << "Opaque NT and D3DKMT handle";
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
return os << "Sync fd semaphore handle";
}
return os;