mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 22:19:02 +00:00
ac63117231
Use the correct print format specifiers for `uint64_t` and fix loop index type to address sign warning. Signed-off-by: Ahmed Hesham <ahmed.hesham@arm.com>
523 lines
21 KiB
C++
523 lines
21 KiB
C++
//
|
|
// Copyright (c) 2024 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#include <vulkan_interop_common.hpp>
|
|
#include <opencl_vulkan_wrapper.hpp>
|
|
#include <vulkan_wrapper.hpp>
|
|
#if !defined(__APPLE__)
|
|
#include <CL/cl.h>
|
|
#include <CL/cl_ext.h>
|
|
#else
|
|
#include <OpenCL/cl.h>
|
|
#include <OpenCL/cl_ext.h>
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <string.h>
|
|
#include <inttypes.h>
|
|
#include "harness/testHarness.h"
|
|
#include "harness/typeWrappers.h"
|
|
#include "harness/deviceInfo.h"
|
|
|
|
#include "vulkan_test_base.h"
|
|
#include "opencl_vulkan_wrapper.hpp"
|
|
|
|
namespace {
|
|
|
|
struct ConsistencyExternalBufferTest : public VulkanTestBase
|
|
{
|
|
ConsistencyExternalBufferTest(cl_device_id device, cl_context context,
|
|
cl_command_queue queue, cl_int nelems)
|
|
: VulkanTestBase(device, context, queue, nelems)
|
|
{}
|
|
|
|
cl_int Run() override
|
|
{
|
|
|
|
cl_int errNum = CL_SUCCESS;
|
|
uint32_t bufferSize = 32;
|
|
|
|
#ifdef _WIN32
|
|
if (!is_extension_available(device, "cl_khr_external_memory_win32"))
|
|
{
|
|
throw std::runtime_error(
|
|
"Device does not support "
|
|
"cl_khr_external_memory_win32 extension \n");
|
|
}
|
|
#else
|
|
if (!is_extension_available(device, "cl_khr_external_memory_opaque_fd"))
|
|
{
|
|
log_info("Device does not support "
|
|
"cl_khr_external_memory_opaque_fd extension \n");
|
|
return TEST_SKIPPED_ITSELF;
|
|
}
|
|
#endif
|
|
|
|
VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
|
|
getSupportedVulkanExternalMemoryHandleTypeList(
|
|
vkDevice->getPhysicalDevice())[0];
|
|
|
|
VulkanBuffer vkDummyBuffer(*vkDevice, 4 * 1024,
|
|
vkExternalMemoryHandleType);
|
|
const VulkanMemoryTypeList& memoryTypeList =
|
|
vkDummyBuffer.getMemoryTypeList();
|
|
|
|
VulkanBufferList vkBufferList(1, *vkDevice, bufferSize,
|
|
vkExternalMemoryHandleType);
|
|
VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
|
|
*vkDevice, vkBufferList[0], memoryTypeList[0],
|
|
vkExternalMemoryHandleType);
|
|
|
|
vkDeviceMem->bindBuffer(vkBufferList[0], 0);
|
|
|
|
[[maybe_unused]] void* handle = NULL;
|
|
[[maybe_unused]] int fd;
|
|
|
|
std::vector<cl_mem_properties> extMemProperties{
|
|
(cl_mem_properties)CL_MEM_DEVICE_HANDLE_LIST_KHR,
|
|
(cl_mem_properties)device,
|
|
(cl_mem_properties)CL_MEM_DEVICE_HANDLE_LIST_END_KHR,
|
|
};
|
|
cl_external_memory_handle_type_khr type;
|
|
switch (vkExternalMemoryHandleType)
|
|
{
|
|
#ifdef _WIN32
|
|
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
|
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
|
|
type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR;
|
|
errNum = check_external_memory_handle_type(device, type);
|
|
extMemProperties.push_back((cl_mem_properties)type);
|
|
extMemProperties.push_back((cl_mem_properties)handle);
|
|
break;
|
|
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
|
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
|
|
type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR;
|
|
errNum = check_external_memory_handle_type(device, type);
|
|
extMemProperties.push_back((cl_mem_properties)type);
|
|
extMemProperties.push_back((cl_mem_properties)handle);
|
|
break;
|
|
#else
|
|
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
|
|
fd = (int)vkDeviceMem->getHandle(vkExternalMemoryHandleType);
|
|
type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR;
|
|
errNum = check_external_memory_handle_type(device, type);
|
|
extMemProperties.push_back((cl_mem_properties)type);
|
|
extMemProperties.push_back((cl_mem_properties)fd);
|
|
break;
|
|
#endif
|
|
default:
|
|
errNum = TEST_FAIL;
|
|
log_error("Unsupported external memory handle type \n");
|
|
break;
|
|
}
|
|
if (errNum != CL_SUCCESS)
|
|
{
|
|
log_error("Checks failed for "
|
|
"CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR\n");
|
|
return TEST_FAIL;
|
|
}
|
|
extMemProperties.push_back(0);
|
|
|
|
clMemWrapper buffer;
|
|
|
|
// Passing NULL properties and a valid extMem_desc size
|
|
buffer = clCreateBufferWithProperties(context, NULL, 1, bufferSize,
|
|
NULL, &errNum);
|
|
test_error(errNum, "Unable to create buffer with NULL properties");
|
|
|
|
buffer.reset();
|
|
|
|
// Passing valid extMemProperties and buffersize
|
|
buffer = clCreateBufferWithProperties(context, extMemProperties.data(),
|
|
1, bufferSize, NULL, &errNum);
|
|
test_error(errNum, "Unable to create buffer with Properties");
|
|
|
|
buffer.reset();
|
|
|
|
// Not passing external memory handle
|
|
std::vector<cl_mem_properties> extMemProperties2{
|
|
#ifdef _WIN32
|
|
(cl_mem_properties)type,
|
|
NULL, // Passing NULL handle
|
|
#else
|
|
(cl_mem_properties)type,
|
|
(cl_mem_properties)-64, // Passing random invalid fd
|
|
#endif
|
|
(cl_mem_properties)CL_MEM_DEVICE_HANDLE_LIST_KHR,
|
|
(cl_mem_properties)device,
|
|
(cl_mem_properties)CL_MEM_DEVICE_HANDLE_LIST_END_KHR,
|
|
0
|
|
};
|
|
buffer = clCreateBufferWithProperties(context, extMemProperties2.data(),
|
|
1, bufferSize, NULL, &errNum);
|
|
test_failure_error(errNum, CL_INVALID_VALUE,
|
|
"Should return CL_INVALID_VALUE ");
|
|
|
|
buffer.reset();
|
|
|
|
// Passing extMem_desc size = 0 but valid memProperties, CL_INVALID_SIZE
|
|
// should be returned.
|
|
buffer = clCreateBufferWithProperties(context, extMemProperties.data(),
|
|
1, 0, NULL, &errNum);
|
|
test_failure_error(errNum, CL_INVALID_BUFFER_SIZE,
|
|
"Should return CL_INVALID_BUFFER_SIZE");
|
|
|
|
return TEST_PASS;
|
|
}
|
|
};
|
|
|
|
struct ConsistencyExternalImageTest : public VulkanTestBase
|
|
{
|
|
ConsistencyExternalImageTest(cl_device_id device, cl_context context,
|
|
cl_command_queue queue, cl_int nelems)
|
|
: VulkanTestBase(device, context, queue, nelems)
|
|
{}
|
|
|
|
cl_int Run() override
|
|
{
|
|
cl_int errNum = CL_SUCCESS;
|
|
|
|
#ifdef _WIN32
|
|
if (!is_extension_available(device, "cl_khr_external_memory_win32"))
|
|
{
|
|
throw std::runtime_error(
|
|
"Device does not support"
|
|
"cl_khr_external_memory_win32 extension \n");
|
|
}
|
|
#else
|
|
if (!is_extension_available(device, "cl_khr_external_memory_opaque_fd"))
|
|
{
|
|
log_info("Device does not support cl_khr_external_memory_opaque_fd "
|
|
"extension \n");
|
|
return TEST_SKIPPED_ITSELF;
|
|
}
|
|
#endif
|
|
uint32_t width = 256;
|
|
uint32_t height = 16;
|
|
cl_image_desc image_desc;
|
|
memset(&image_desc, 0x0, sizeof(cl_image_desc));
|
|
cl_image_format img_format = { 0 };
|
|
|
|
VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
|
|
getSupportedVulkanExternalMemoryHandleTypeList(
|
|
vkDevice->getPhysicalDevice())[0];
|
|
|
|
auto vulkanImageTiling = vkClExternalMemoryHandleTilingAssumption(
|
|
device, vkExternalMemoryHandleType, &errNum);
|
|
ASSERT_SUCCESS(errNum, "Failed to query OpenCL tiling mode");
|
|
if (vulkanImageTiling == std::nullopt)
|
|
{
|
|
log_info("No image tiling supported by both Vulkan and OpenCL "
|
|
"could be found\n");
|
|
return TEST_SKIPPED_ITSELF;
|
|
}
|
|
|
|
VulkanImage2D vkImage2D = VulkanImage2D(
|
|
*vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height,
|
|
*vulkanImageTiling, 1, vkExternalMemoryHandleType);
|
|
|
|
const VulkanMemoryTypeList& memoryTypeList =
|
|
vkImage2D.getMemoryTypeList();
|
|
|
|
log_info("Memory type index: %u\n", (uint32_t)memoryTypeList[0]);
|
|
log_info("Memory type property: %d\n",
|
|
memoryTypeList[0].getMemoryTypeProperty());
|
|
log_info("Image size : %" PRIu64 "\n", vkImage2D.getSize());
|
|
|
|
VulkanDeviceMemory* vkDeviceMem =
|
|
new VulkanDeviceMemory(*vkDevice, vkImage2D, memoryTypeList[0],
|
|
vkExternalMemoryHandleType);
|
|
vkDeviceMem->bindImage(vkImage2D, 0);
|
|
|
|
[[maybe_unused]] void* handle = NULL;
|
|
[[maybe_unused]] int fd;
|
|
std::vector<cl_mem_properties> extMemProperties{
|
|
(cl_mem_properties)CL_MEM_DEVICE_HANDLE_LIST_KHR,
|
|
(cl_mem_properties)device,
|
|
(cl_mem_properties)CL_MEM_DEVICE_HANDLE_LIST_END_KHR,
|
|
};
|
|
switch (vkExternalMemoryHandleType)
|
|
{
|
|
#ifdef _WIN32
|
|
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
|
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
|
|
errNum = check_external_memory_handle_type(
|
|
device, CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
|
|
extMemProperties.push_back(
|
|
(cl_mem_properties)
|
|
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
|
|
extMemProperties.push_back((cl_mem_properties)handle);
|
|
break;
|
|
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
|
handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
|
|
errNum = check_external_memory_handle_type(
|
|
device, CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
|
extMemProperties.push_back(
|
|
(cl_mem_properties)
|
|
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
|
extMemProperties.push_back((cl_mem_properties)handle);
|
|
break;
|
|
#else
|
|
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
|
|
fd = (int)vkDeviceMem->getHandle(vkExternalMemoryHandleType);
|
|
errNum = check_external_memory_handle_type(
|
|
device, CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
|
|
extMemProperties.push_back(
|
|
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
|
|
extMemProperties.push_back((cl_mem_properties)fd);
|
|
break;
|
|
#endif
|
|
default:
|
|
errNum = TEST_FAIL;
|
|
log_error("Unsupported external memory handle type \n");
|
|
break;
|
|
}
|
|
if (errNum != CL_SUCCESS)
|
|
{
|
|
log_error("Checks failed for "
|
|
"CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR\n");
|
|
return TEST_FAIL;
|
|
}
|
|
extMemProperties.push_back(0);
|
|
|
|
const VkImageCreateInfo VulkanImageCreateInfo =
|
|
vkImage2D.getVkImageCreateInfo();
|
|
|
|
auto layout = vkImage2D.getSubresourceLayout();
|
|
errNum = getCLImageInfoFromVkImageInfo(
|
|
device, &VulkanImageCreateInfo, &img_format, &image_desc,
|
|
vulkanImageTiling == VULKAN_IMAGE_TILING_LINEAR ? &layout
|
|
: nullptr);
|
|
test_error_fail(errNum, "getCLImageInfoFromVkImageInfo failed!!!");
|
|
|
|
clMemWrapper image;
|
|
|
|
// Pass valid properties, image_desc and image_format
|
|
image = clCreateImageWithProperties(
|
|
context, extMemProperties.data(), CL_MEM_READ_WRITE, &img_format,
|
|
&image_desc, NULL /* host_ptr */, &errNum);
|
|
test_error(errNum, "Unable to create Image with Properties");
|
|
image.reset();
|
|
|
|
// Passing image_format as NULL
|
|
image = clCreateImageWithProperties(context, extMemProperties.data(),
|
|
CL_MEM_READ_WRITE, NULL,
|
|
&image_desc, NULL, &errNum);
|
|
test_failure_error(errNum, CL_INVALID_IMAGE_FORMAT_DESCRIPTOR,
|
|
"Image creation must fail with "
|
|
"CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"
|
|
"when image desc passed as NULL");
|
|
|
|
image.reset();
|
|
|
|
// Passing image_desc as NULL
|
|
image = clCreateImageWithProperties(context, extMemProperties.data(),
|
|
CL_MEM_READ_WRITE, &img_format,
|
|
NULL, NULL, &errNum);
|
|
test_failure_error(errNum, CL_INVALID_IMAGE_DESCRIPTOR,
|
|
"Image creation must fail with "
|
|
"CL_INVALID_IMAGE_DESCRIPTOR "
|
|
"when image desc passed as NULL");
|
|
image.reset();
|
|
|
|
return TEST_PASS;
|
|
}
|
|
};
|
|
|
|
struct ConsistencyExternalSemaphoreTest : public VulkanTestBase
|
|
{
|
|
ConsistencyExternalSemaphoreTest(cl_device_id device, cl_context context,
|
|
cl_command_queue queue, cl_int nelems)
|
|
: VulkanTestBase(device, context, queue, nelems)
|
|
{}
|
|
|
|
cl_int Run() override
|
|
{
|
|
cl_int errNum = CL_SUCCESS;
|
|
|
|
#ifdef _WIN32
|
|
if (!is_extension_available(device, "cl_khr_external_memory_win32"))
|
|
{
|
|
throw std::runtime_error(
|
|
"Device does not support"
|
|
"cl_khr_external_memory_win32 extension \n");
|
|
}
|
|
#else
|
|
if (!is_extension_available(device, "cl_khr_external_memory_opaque_fd"))
|
|
{
|
|
log_info("Device does not support cl_khr_external_memory_opaque_fd "
|
|
"extension \n");
|
|
return TEST_SKIPPED_ITSELF;
|
|
}
|
|
#endif
|
|
|
|
std::vector<VulkanExternalSemaphoreHandleType>
|
|
supportedExternalSemaphores =
|
|
getSupportedInteropExternalSemaphoreHandleTypes(device,
|
|
*vkDevice);
|
|
|
|
if (supportedExternalSemaphores.empty())
|
|
{
|
|
test_fail("No supported external semaphore types found\n");
|
|
}
|
|
|
|
for (VulkanExternalSemaphoreHandleType semaphoreHandleType :
|
|
supportedExternalSemaphores)
|
|
{
|
|
check_external_semaphore_handle_type(
|
|
device, getCLSemaphoreTypeFromVulkanType(semaphoreHandleType),
|
|
CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR);
|
|
|
|
VulkanSemaphore vkVk2Clsemaphore(*vkDevice, semaphoreHandleType);
|
|
VulkanSemaphore vkCl2Vksemaphore(*vkDevice, semaphoreHandleType);
|
|
cl_semaphore_khr clCl2Vksemaphore;
|
|
cl_semaphore_khr clVk2Clsemaphore;
|
|
[[maybe_unused]] void* handle1 = NULL;
|
|
[[maybe_unused]] void* handle2 = NULL;
|
|
[[maybe_unused]] int fd1, fd2;
|
|
std::vector<cl_semaphore_properties_khr> sema_props1{
|
|
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
|
|
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
|
|
};
|
|
std::vector<cl_semaphore_properties_khr> sema_props2{
|
|
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
|
|
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
|
|
};
|
|
|
|
switch (semaphoreHandleType)
|
|
{
|
|
#ifdef _WIN32
|
|
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
|
log_info(
|
|
" Opaque NT handles are only supported on Windows\n");
|
|
handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType);
|
|
handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType);
|
|
sema_props1.push_back(
|
|
(cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
|
|
sema_props1.push_back((cl_semaphore_properties_khr)handle1);
|
|
sema_props2.push_back(
|
|
(cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)handle2);
|
|
break;
|
|
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
|
log_info(" Opaque D3DKMT handles are only supported on "
|
|
"Windows\n");
|
|
handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType);
|
|
handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType);
|
|
sema_props1.push_back(
|
|
(cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
|
sema_props1.push_back((cl_semaphore_properties_khr)handle1);
|
|
sema_props2.push_back(
|
|
(cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)handle2);
|
|
break;
|
|
#else
|
|
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
|
|
fd1 = (int)vkVk2Clsemaphore.getHandle(semaphoreHandleType);
|
|
fd2 = (int)vkCl2Vksemaphore.getHandle(semaphoreHandleType);
|
|
sema_props1.push_back(
|
|
(cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
|
|
sema_props1.push_back((cl_semaphore_properties_khr)fd1);
|
|
sema_props2.push_back(
|
|
(cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)fd2);
|
|
break;
|
|
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
|
|
fd1 = -1;
|
|
fd2 = -1;
|
|
sema_props1.push_back((cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
|
|
sema_props1.push_back((cl_semaphore_properties_khr)fd1);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_HANDLE_SYNC_FD_KHR);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)fd2);
|
|
break;
|
|
#endif
|
|
default:
|
|
log_error("Unsupported external memory handle type\n");
|
|
break;
|
|
}
|
|
if (CL_SUCCESS != errNum)
|
|
{
|
|
throw std::runtime_error(
|
|
"Unsupported external semaphore handle type\n ");
|
|
}
|
|
sema_props1.push_back((cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR);
|
|
sema_props1.push_back((cl_semaphore_properties_khr)device);
|
|
sema_props1.push_back((cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_DEVICE_HANDLE_LIST_END_KHR);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)device);
|
|
sema_props2.push_back((cl_semaphore_properties_khr)
|
|
CL_SEMAPHORE_DEVICE_HANDLE_LIST_END_KHR);
|
|
sema_props1.push_back(0);
|
|
sema_props2.push_back(0);
|
|
|
|
// Create two semaphore objects
|
|
clVk2Clsemaphore = clCreateSemaphoreWithPropertiesKHRptr(
|
|
context, sema_props1.data(), &errNum);
|
|
test_error(
|
|
errNum,
|
|
"Unable to create semaphore with valid semaphore properties");
|
|
|
|
clCl2Vksemaphore = clCreateSemaphoreWithPropertiesKHRptr(
|
|
context, sema_props2.data(), &errNum);
|
|
test_error(
|
|
errNum,
|
|
"Unable to create semaphore with valid semaphore properties");
|
|
|
|
// Release both semaphore objects
|
|
errNum = clReleaseSemaphoreKHRptr(clVk2Clsemaphore);
|
|
test_error(errNum, "clReleaseSemaphoreKHRptr failed");
|
|
|
|
errNum = clReleaseSemaphoreKHRptr(clCl2Vksemaphore);
|
|
test_error(errNum, "clReleaseSemaphoreKHRptr failed");
|
|
}
|
|
|
|
return TEST_PASS;
|
|
}
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
REGISTER_TEST(test_consistency_external_buffer)
|
|
{
|
|
return MakeAndRunTest<ConsistencyExternalBufferTest>(device, context, queue,
|
|
num_elements);
|
|
}
|
|
|
|
REGISTER_TEST(test_consistency_external_image)
|
|
{
|
|
return MakeAndRunTest<ConsistencyExternalImageTest>(device, context, queue,
|
|
num_elements);
|
|
}
|
|
|
|
REGISTER_TEST(test_consistency_external_semaphore)
|
|
{
|
|
return MakeAndRunTest<ConsistencyExternalSemaphoreTest>(
|
|
device, context, queue, num_elements);
|
|
}
|