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

cl_khr_external_memory_ahb test (#2413)

Browse Source 
Android AHardwareBuffer test. Initial testing for buffers and image.

---------

Co-authored-by: joselope <joselope@qti.qualcomm.com>
This commit is contained in:
dcrawleyqti
2025-08-05 12:32:02 -04:00
committed by GitHub
parent 4c54ecbd1f
commit 086a6c67fb
7 changed files with 2427 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test_conformance/extensions/CMakeLists.txt
View File

@@ -5,6 +5,9 @@
add_subdirectory( cl_ext_cxx_for_opencl )
add_subdirectory( cl_khr_command_buffer )
add_subdirectory( cl_khr_dx9_media_sharing )
if(ANDROID_PLATFORM GREATER 28)
add_subdirectory( cl_khr_external_memory_ahb )
endif ()
add_subdirectory( cl_khr_external_memory_dma_buf )
add_subdirectory( cl_khr_semaphore )
add_subdirectory( cl_khr_kernel_clock )

12
test_conformance/extensions/cl_khr_external_memory_ahb/CMakeLists.txt Normal file
View File

@@ -0,0 +1,12 @@
set(MODULE_NAME CL_KHR_EXTERNAL_MEMORY_AHB)
set(${MODULE_NAME}_SOURCES
main.cpp
test_ahb.cpp
test_ahb_negative.cpp
debug_ahb.cpp
)
link_libraries(OpenCL nativewindow)
include(../../CMakeCommon.txt)

190
test_conformance/extensions/cl_khr_external_memory_ahb/debug_ahb.cpp Normal file
View File

@@ -0,0 +1,190 @@
//
// Copyright (c) 2025 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 "debug_ahb.h"
constexpr AHardwareBuffer_UsageFlags flag_list[] = {
AHARDWAREBUFFER_USAGE_CPU_READ_RARELY,
AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER,
AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY,
AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK,
AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE,
AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER,
AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY,
AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT,
AHARDWAREBUFFER_USAGE_VIDEO_ENCODE,
AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA,
AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP,
AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE,
AHARDWAREBUFFER_USAGE_FRONT_BUFFER,
};
std::string
ahardwareBufferDecodeUsageFlagsToString(const AHardwareBuffer_UsageFlags flags)
{
if (flags == 0)
{
return "UNKNOWN FLAG";
}
std::vector<std::string> active_flags;
for (const auto flag : flag_list)
{
if (flag & flags)
{
active_flags.push_back(ahardwareBufferUsageFlagToString(flag));
}
}
if (active_flags.empty())
{
return "UNKNOWN FLAG";
}
return std::accumulate(active_flags.begin() + 1, active_flags.end(),
active_flags.front(),
[](std::string acc, const std::string& flag) {
return std::move(acc) + "|" + flag;
});
}
std::string
ahardwareBufferUsageFlagToString(const AHardwareBuffer_UsageFlags flag)
{
std::string result;
switch (flag)
{
case AHARDWAREBUFFER_USAGE_CPU_READ_NEVER:
result = "AHARDWAREBUFFER_USAGE_CPU_READ_NEVER";
break;
case AHARDWAREBUFFER_USAGE_CPU_READ_RARELY:
result = "AHARDWAREBUFFER_USAGE_CPU_READ_RARELY";
break;
case AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN:
result = "AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN";
break;
case AHARDWAREBUFFER_USAGE_CPU_READ_MASK:
result = "AHARDWAREBUFFER_USAGE_CPU_READ_MASK";
break;
case AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY:
result = "AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY";
break;
case AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN:
result = "AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN";
break;
case AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK:
result = "AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK";
break;
case AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE:
result = "AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE";
break;
case AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER:
result = "AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER";
break;
case AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY:
result = "AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY";
break;
case AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT:
result = "AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT";
break;
case AHARDWAREBUFFER_USAGE_VIDEO_ENCODE:
result = "AHARDWAREBUFFER_USAGE_VIDEO_ENCODE";
break;
case AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA:
result = "AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA";
break;
case AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER:
result = "AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER";
break;
case AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP:
result = "AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP";
break;
case AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE:
result = "AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE";
break;
default: result = "Unknown flag";
}
return result;
}
std::string ahardwareBufferFormatToString(AHardwareBuffer_Format format)
{
std::string result;
switch (format)
{
case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
result = "AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT";
break;
case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_BLOB:
result = "AHARDWAREBUFFER_FORMAT_BLOB";
break;
case AHARDWAREBUFFER_FORMAT_D16_UNORM:
result = "AHARDWAREBUFFER_FORMAT_D16_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_D24_UNORM:
result = "AHARDWAREBUFFER_FORMAT_D24_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
result = "AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT";
break;
case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
result = "AHARDWAREBUFFER_FORMAT_D32_FLOAT";
break;
case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
result = "AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT";
break;
case AHARDWAREBUFFER_FORMAT_S8_UINT:
result = "AHARDWAREBUFFER_FORMAT_S8_UINT";
break;
case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
result = "AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420";
break;
case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
result = "AHARDWAREBUFFER_FORMAT_YCbCr_P010";
break;
case AHARDWAREBUFFER_FORMAT_R8_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R8_UNORM";
break;
case AHARDWAREBUFFER_FORMAT_R16_UINT:
result = "AHARDWAREBUFFER_FORMAT_R16_UINT";
break;
case AHARDWAREBUFFER_FORMAT_R16G16_UINT:
result = "AHARDWAREBUFFER_FORMAT_R16G16_UINT";
break;
case AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM:
result = "AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM";
break;
}
return result;
}

42
test_conformance/extensions/cl_khr_external_memory_ahb/debug_ahb.h Normal file
View File

@@ -0,0 +1,42 @@
//
// Copyright (c) 2025 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.
//
#pragma once
#include <android/hardware_buffer.h>
#include <string>
#include <vector>
#include <numeric>
#define CHECK_AHARDWARE_BUFFER_SUPPORT(ahardwareBuffer_Desc, format) \
if (!AHardwareBuffer_isSupported(&ahardwareBuffer_Desc)) \
{ \
const std::string usage_string = \
ahardwareBufferDecodeUsageFlagsToString( \
static_cast<AHardwareBuffer_UsageFlags>( \
ahardwareBuffer_Desc.usage)); \
log_info("Unsupported format %s:\n Usage flags %s\n Size (%u, " \
"%u, layers = %u)\n", \
ahardwareBufferFormatToString(format.aHardwareBufferFormat) \
.c_str(), \
usage_string.c_str(), ahardwareBuffer_Desc.width, \
ahardwareBuffer_Desc.height, ahardwareBuffer_Desc.layers); \
continue; \
}
std::string ahardwareBufferFormatToString(AHardwareBuffer_Format format);
std::string ahardwareBufferUsageFlagToString(AHardwareBuffer_UsageFlags flag);
std::string
ahardwareBufferDecodeUsageFlagsToString(AHardwareBuffer_UsageFlags flags);

23
test_conformance/extensions/cl_khr_external_memory_ahb/main.cpp Normal file
View File

@@ -0,0 +1,23 @@
//
// Copyright (c) 2025 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 "harness/testHarness.h"
int main(int argc, const char *argv[])
{
return runTestHarness(argc, argv, test_registry::getInstance().num_tests(),
test_registry::getInstance().definitions(), false, 0);
}

1911
test_conformance/extensions/cl_khr_external_memory_ahb/test_ahb.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

246
test_conformance/extensions/cl_khr_external_memory_ahb/test_ahb_negative.cpp Normal file
View File

@@ -0,0 +1,246 @@
//
// Copyright (c) 2025 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 "harness/compat.h"
#include "harness/kernelHelpers.h"
#include "harness/imageHelpers.h"
#include "harness/errorHelpers.h"
#include <android/hardware_buffer.h>
#include "debug_ahb.h"
REGISTER_TEST(test_buffer_format_negative)
{
cl_int err = CL_SUCCESS;
if (!is_extension_available(device, "cl_khr_external_memory"))
{
log_info("cl_khr_external_memory is not supported on this platform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (!is_extension_available(
device, "cl_khr_external_memory_android_hardware_buffer"))
{
log_info("cl_khr_external_memory_android_hardware_buffer is not "
"supported on this platform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
AHardwareBuffer_Desc aHardwareBufferDesc = { 0 };
aHardwareBufferDesc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
aHardwareBufferDesc.usage = AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
aHardwareBufferDesc.width = 64;
aHardwareBufferDesc.height = 1;
aHardwareBufferDesc.layers = 1;
aHardwareBufferDesc.usage = AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
if (!AHardwareBuffer_isSupported(&aHardwareBufferDesc))
{
const std::string usage_string =
ahardwareBufferDecodeUsageFlagsToString(
static_cast<AHardwareBuffer_UsageFlags>(
aHardwareBufferDesc.usage));
log_info(
"Unsupported format %s, usage flags %s\n",
ahardwareBufferFormatToString(
static_cast<AHardwareBuffer_Format>(aHardwareBufferDesc.format))
.c_str(),
usage_string.c_str());
return TEST_SKIPPED_ITSELF;
}
AHardwareBuffer *aHardwareBuffer = nullptr;
const int ahb_result =
AHardwareBuffer_allocate(&aHardwareBufferDesc, &aHardwareBuffer);
if (ahb_result != 0)
{
log_error("AHardwareBuffer_allocate failed with code %d\n", ahb_result);
return TEST_FAIL;
}
log_info("Testing %s\n",
ahardwareBufferFormatToString(static_cast<AHardwareBuffer_Format>(
aHardwareBufferDesc.format))
.c_str());
cl_mem_properties props[] = {
CL_EXTERNAL_MEMORY_HANDLE_AHB_KHR,
reinterpret_cast<cl_mem_properties>(aHardwareBuffer), 0
};
cl_mem buffer = clCreateBufferWithProperties(
context, props, CL_MEM_READ_WRITE, 0, nullptr, &err);
test_assert_error(err == CL_INVALID_OPERATION,
"To create a buffer the aHardwareFormat must be "
"AHARDWAREBUFFER_FORMAT_BLOB");
if (buffer != nullptr)
{
test_error(clReleaseMemObject(buffer), "Failed to release buffer");
}
AHardwareBuffer_release(aHardwareBuffer);
aHardwareBuffer = nullptr;
return TEST_PASS;
}
REGISTER_TEST(test_buffer_size_negative)
{
cl_int err = CL_SUCCESS;
constexpr size_t buffer_size = 64;
if (!is_extension_available(device, "cl_khr_external_memory"))
{
log_info("cl_khr_external_memory is not supported on this platform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (!is_extension_available(
device, "cl_khr_external_memory_android_hardware_buffer"))
{
log_info("cl_khr_external_memory_android_hardware_buffer is not "
"supported on this platform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
AHardwareBuffer_Desc aHardwareBufferDesc = { 0 };
aHardwareBufferDesc.format = AHARDWAREBUFFER_FORMAT_BLOB;
aHardwareBufferDesc.usage = AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
aHardwareBufferDesc.width = buffer_size;
aHardwareBufferDesc.height = 1;
aHardwareBufferDesc.layers = 1;
aHardwareBufferDesc.usage = AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
if (!AHardwareBuffer_isSupported(&aHardwareBufferDesc))
{
const std::string usage_string =
ahardwareBufferDecodeUsageFlagsToString(
static_cast<AHardwareBuffer_UsageFlags>(
aHardwareBufferDesc.usage));
log_info(
"Unsupported format %s, usage flags %s\n",
ahardwareBufferFormatToString(
static_cast<AHardwareBuffer_Format>(aHardwareBufferDesc.format))
.c_str(),
usage_string.c_str());
return TEST_SKIPPED_ITSELF;
}
AHardwareBuffer *aHardwareBuffer = nullptr;
const int ahb_result =
AHardwareBuffer_allocate(&aHardwareBufferDesc, &aHardwareBuffer);
if (ahb_result != 0)
{
log_error("AHardwareBuffer_allocate failed with code %d\n", ahb_result);
return TEST_FAIL;
}
log_info("Testing %s\n",
ahardwareBufferFormatToString(static_cast<AHardwareBuffer_Format>(
aHardwareBufferDesc.format))
.c_str());
cl_mem_properties props[] = {
CL_EXTERNAL_MEMORY_HANDLE_AHB_KHR,
reinterpret_cast<cl_mem_properties>(aHardwareBuffer), 0
};
cl_mem buffer = clCreateBufferWithProperties(
context, props, CL_MEM_READ_WRITE, buffer_size / 2, nullptr, &err);
test_assert_error(err == CL_INVALID_BUFFER_SIZE,
"Wrong error value returned");
if (buffer != nullptr)
{
test_error(clReleaseMemObject(buffer), "Failed to release buffer");
}
AHardwareBuffer_release(aHardwareBuffer);
aHardwareBuffer = nullptr;
return TEST_PASS;
}
REGISTER_TEST(test_images_negative)
{
cl_int err = CL_SUCCESS;
if (!is_extension_available(device, "cl_khr_external_memory"))
{
log_info("cl_khr_external_memory is not supported on this platform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
if (!is_extension_available(
device, "cl_khr_external_memory_android_hardware_buffer"))
{
log_info("cl_khr_external_memory_android_hardware_buffer is not "
"supported on this platform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
AHardwareBuffer_Desc aHardwareBufferDesc = { 0 };
aHardwareBufferDesc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
aHardwareBufferDesc.usage = static_cast<AHardwareBuffer_UsageFlags>(
AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN
| AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN
| AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE
| AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER);
aHardwareBufferDesc.width = 64;
aHardwareBufferDesc.height = 64;
aHardwareBufferDesc.layers = 1;
AHardwareBuffer *aHardwareBuffer = nullptr;
int ahb_result =
AHardwareBuffer_allocate(&aHardwareBufferDesc, &aHardwareBuffer);
if (ahb_result != 0)
{
log_error("AHardwareBuffer_allocate failed with code %d\n", ahb_result);
return TEST_FAIL;
}
const cl_mem_properties props[] = {
CL_EXTERNAL_MEMORY_HANDLE_AHB_KHR,
reinterpret_cast<cl_mem_properties>(aHardwareBuffer), 0
};
constexpr cl_image_format image_format = { CL_RGBA, CL_UNORM_INT8 };
cl_mem image =
clCreateImageWithProperties(context, props, CL_MEM_READ_WRITE,
&image_format, nullptr, nullptr, &err);
test_assert_error(err == CL_INVALID_IMAGE_FORMAT_DESCRIPTOR,
"Wrong error value returned");
if (image != nullptr)
{
test_error(clReleaseMemObject(image), "Failed to release image");
}
constexpr cl_image_desc image_desc = { CL_MEM_OBJECT_IMAGE2D, 64, 64 };
image = clCreateImageWithProperties(context, props, CL_MEM_READ_WRITE,
nullptr, &image_desc, nullptr, &err);
test_assert_error(err == CL_INVALID_IMAGE_DESCRIPTOR,
"Wrong error value returned");
if (image != nullptr)
{
test_error(clReleaseMemObject(image), "Failed to release image");
}
AHardwareBuffer_release(aHardwareBuffer);
aHardwareBuffer = nullptr;
return TEST_PASS;
}