diff --git a/.github/workflows/presubmit.yml b/.github/workflows/presubmit.yml index e52ecb59..2faac8b5 100644 --- a/.github/workflows/presubmit.yml +++ b/.github/workflows/presubmit.yml @@ -5,34 +5,26 @@ jobs: build: name: Build ${{ matrix.os }} ${{ matrix.arch }}${{ matrix.extra }} runs-on: ${{ matrix.os }} - env: - JOB_ARCHITECTURE: ${{ matrix.arch }} - JOB_ENABLE_GL: ${{ matrix.gl }} - JOB_ENABLE_DEBUG: ${{ matrix.debug }} strategy: fail-fast: false matrix: - mainmatrix: [true] + build-type: [Release] + gl: [0] os: [ubuntu-22.04, macos-latest, windows-latest] include: - os: ubuntu-22.04 - mainmatrix: true gl: 1 extra: " gl" - os: ubuntu-22.04 - mainmatrix: false arch: arm - os: ubuntu-22.04 - mainmatrix: false arch: aarch64 - debug: 1 + build-type: Debug extra: " debug" - os: ubuntu-22.04 - mainmatrix: false arch: android-arm android_arch_abi: armeabi-v7a - os: ubuntu-22.04 - mainmatrix: false arch: android-aarch64 android_arch_abi: arm64-v8a steps: @@ -84,9 +76,101 @@ jobs: echo "ANDROID_NDK=$ANDROID_NDK" >> $GITHUB_ENV export ANDROID_ARCH_ABI=${{ matrix.android_arch_abi }} echo "ANDROID_ARCH_ABI=$ANDROID_ARCH_ABI" >> $GITHUB_ENV - - name: Build + - name: Prepare CMake Toolchain file shell: bash - run: ./presubmit.sh + run: | + if [[ '${{ matrix.arch }}' == android-* ]]; then + TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake + else + TOOLCHAIN_FILE='${{ github.workspace }}'/toolchain.cmake + touch ${TOOLCHAIN_FILE} + fi + + TOOLCHAIN_PREFIX_arm=arm-linux-gnueabihf + TOOLCHAIN_PREFIX_aarch64=aarch64-linux-gnu + + if [[ '${{ matrix.arch }}' != android-* ]]; then + if [[ '${{ matrix.arch }}' != "" && ${RUNNER_OS} != "Windows" ]]; then + TOOLCHAIN_PREFIX_VAR=TOOLCHAIN_PREFIX_${{ matrix.arch }} + TOOLCHAIN_PREFIX=${!TOOLCHAIN_PREFIX_VAR} + + echo "SET(CMAKE_SYSTEM_NAME Linux)" >> ${TOOLCHAIN_FILE} + echo "SET(CMAKE_SYSTEM_PROCESSOR ${{ matrix.arch }})" >> ${TOOLCHAIN_FILE} + echo "SET(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)" >> ${TOOLCHAIN_FILE} + echo "SET(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)" >> ${TOOLCHAIN_FILE} + echo "SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)" >> ${TOOLCHAIN_FILE} + echo "SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)" >> ${TOOLCHAIN_FILE} + echo "SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)" >> ${TOOLCHAIN_FILE} + fi + fi + echo "TOOLCHAIN_FILE=${TOOLCHAIN_FILE}" >> $GITHUB_ENV + - name: Prepare Android CMake arguments + if: ${{ matrix.arch == 'android-arm' || matrix.arch == 'android-aarch64' }} + shell: bash + run: | + echo "CMAKE_CONFIG_ARGS_ANDROID=-DCMAKE_ANDROID_ARCH_ABI=${ANDROID_ARCH_ABI}" >> $GITHUB_ENV + - name: Fetch and build OpenCL ICD Loader + shell: bash + run: | + git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader.git + cd OpenCL-ICD-Loader + mkdir build + cd build + cmake .. -G Ninja \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ + -DOPENCL_ICD_LOADER_HEADERS_DIR='${{ github.workspace }}'/OpenCL-Headers/ \ + "${CMAKE_CONFIG_ARGS_ANDROID}" + cmake --build . --parallel + - name: Fetch Vulkan Headers + shell: bash + run: | + git clone https://github.com/KhronosGroup/Vulkan-Headers.git + - name: Fetch and build Vulkan Loader + if: ${{ matrix.arch != 'android-arm' && matrix.arch != 'android-aarch64' }} + shell: bash + run: | + git clone https://github.com/KhronosGroup/Vulkan-Loader.git + cd Vulkan-Loader + mkdir build + cd build + python3 ../scripts/update_deps.py + cmake .. -G Ninja \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ + -DBUILD_WSI_XLIB_SUPPORT=OFF \ + -DBUILD_WSI_XCB_SUPPORT=OFF \ + -DBUILD_WSI_WAYLAND_SUPPORT=OFF \ + -C helper.cmake .. + cmake --build . --parallel + - name: Configure and build + shell: bash + run: | + mkdir build + cd build + if [[ ${RUNNER_OS} == "Windows" ]]; then + CMAKE_OPENCL_LIBRARIES_OPTION="OpenCL" + else + CMAKE_OPENCL_LIBRARIES_OPTION="-lOpenCL" + if [[ '${{ matrix.arch }}' != android-* ]]; then + CMAKE_OPENCL_LIBRARIES_OPTION="${CMAKE_OPENCL_LIBRARIES_OPTION} -lpthread" + fi + fi + cmake .. -G Ninja \ + -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ + -DCMAKE_CACHE_OPTIONS="-DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache" \ + -DCL_INCLUDE_DIR='${{ github.workspace }}'/OpenCL-Headers \ + -DCL_LIB_DIR='${{ github.workspace }}'/OpenCL-ICD-Loader/build \ + -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ + -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=./bin \ + -DOPENCL_LIBRARIES="${CMAKE_OPENCL_LIBRARIES_OPTION}" \ + -DUSE_CL_EXPERIMENTAL=ON \ + -DGL_IS_SUPPORTED=${{ matrix.gl }} \ + -DVULKAN_IS_SUPPORTED=ON \ + -DVULKAN_INCLUDE_DIR='${{ github.workspace }}'/Vulkan-Headers/include/ \ + -DVULKAN_LIB_DIR='${{ github.workspace }}'/Vulkan-Loader/build/loader/ \ + "${CMAKE_CONFIG_ARGS_ANDROID}" + cmake --build . --parallel formatcheck: name: Check code format runs-on: ubuntu-22.04 diff --git a/CMakeLists.txt b/CMakeLists.txt index 8a93ea9f..f34ade8e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,7 +7,7 @@ project(CLConform${CONFORMANCE_SUFFIX}) set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED ON) -set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) add_definitions(-DCL_TARGET_OPENCL_VERSION=300) @@ -100,7 +100,11 @@ if(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?Clang" add_cxx_flag_if_supported(-Wmisleading-indentation) add_cxx_flag_if_supported(-Wunused-function) add_cxx_flag_if_supported(-Wunused-variable) - add_cxx_flag_if_supported(-Werror) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24") + set(CMAKE_COMPILE_WARNING_AS_ERROR ON) + else() + add_cxx_flag_if_supported(-Werror) + endif() if(NOT CMAKE_BUILD_TYPE MATCHES "Release|RelWithDebInfo|MinSizeRel") # Enable more warnings if not doing a release build. add_cxx_flag_if_supported(-Wall) diff --git a/README.md b/README.md index 6d46ce99..0cc09b1b 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,9 @@ Compiling the CTS requires the following CMake configuration options to be set: * `CL_INCLUDE_DIR` Points to the unified [OpenCL-Headers](https://github.com/KhronosGroup/OpenCL-Headers). * `CL_LIB_DIR` Directory containing the OpenCL library to build against. +* `SPIRV_TOOLS_DIR` Directory containing the `spirv-as` and `spirv-val` binaries + to be used in the CTS build process. Alternatively, the location to these binaries + can be provided via the `PATH` variable. * `OPENCL_LIBRARIES` Name of the OpenCL library to link. It is advised that the [OpenCL ICD-Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader) @@ -29,16 +32,26 @@ a build, and compile. git clone https://github.com/KhronosGroup/OpenCL-CTS.git git clone https://github.com/KhronosGroup/OpenCL-Headers.git git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader.git +git clone https://github.com/KhronosGroup/SPIRV-Tools.git +git clone https://github.com/KhronosGroup/SPIRV-Headers.git SPIRV-Tools/external/spirv-headers +git clone https://github.com/google/effcee.git SPIRV-Tools/external/effcee +git clone https://github.com/google/re2.git SPIRV-Tools/external/re2 + mkdir OpenCL-ICD-Loader/build cmake -S OpenCL-ICD-Loader -B OpenCL-ICD-Loader/build \ -DOPENCL_ICD_LOADER_HEADERS_DIR=$PWD/OpenCL-Headers cmake --build ./OpenCL-ICD-Loader/build --config Release +mkdir SPIRV-Tools/build +cmake -S SPIRV-Tools -B SPIRV-Tools/build -DSPIRV_SKIP_TESTS=ON +cmake --build SPIRV-Tools/build --config Release + mkdir OpenCL-CTS/build cmake -S OpenCL-CTS -B OpenCL-CTS/build \ -DCL_INCLUDE_DIR=$PWD/OpenCL-Headers \ -DCL_LIB_DIR=$PWD/OpenCL-ICD-Loader/build \ + -DSPIRV_TOOLS_DIR=$PWD/SPIRV-Tools/build/tools/ \ -DOPENCL_LIBRARIES=OpenCL cmake --build OpenCL-CTS/build --config Release ``` diff --git a/presubmit.sh b/presubmit.sh deleted file mode 100755 index b0218265..00000000 --- a/presubmit.sh +++ /dev/null @@ -1,112 +0,0 @@ -#!/usr/bin/env bash - -set -e - -export TOP=$(pwd) - -TOOLCHAIN_PREFIX_arm=arm-linux-gnueabihf -TOOLCHAIN_PREFIX_aarch64=aarch64-linux-gnu - -if [[ ${JOB_ARCHITECTURE} == android-* ]]; then - TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake - CMAKE_CONFIG_ARGS_ANDROID="-DCMAKE_ANDROID_ARCH_ABI=${ANDROID_ARCH_ABI}" -else - TOOLCHAIN_FILE=${TOP}/toolchain.cmake - touch ${TOOLCHAIN_FILE} -fi - -BUILD_OPENGL_TEST="OFF" -BUILD_VULKAN_TEST="ON" - -cmake --version -echo - -# Prepare toolchain if needed -if [[ ${JOB_ARCHITECTURE} != android-* ]]; then - if [[ ${JOB_ARCHITECTURE} != "" && ${RUNNER_OS} != "Windows" ]]; then - TOOLCHAIN_PREFIX_VAR=TOOLCHAIN_PREFIX_${JOB_ARCHITECTURE} - TOOLCHAIN_PREFIX=${!TOOLCHAIN_PREFIX_VAR} - - echo "SET(CMAKE_SYSTEM_NAME Linux)" >> ${TOOLCHAIN_FILE} - echo "SET(CMAKE_SYSTEM_PROCESSOR ${JOB_ARCHITECTURE})" >> ${TOOLCHAIN_FILE} - echo "SET(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)" >> ${TOOLCHAIN_FILE} - echo "SET(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)" >> ${TOOLCHAIN_FILE} - echo "SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)" >> ${TOOLCHAIN_FILE} - echo "SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)" >> ${TOOLCHAIN_FILE} - echo "SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)" >> ${TOOLCHAIN_FILE} - fi -fi - -if [[ ( ${JOB_ARCHITECTURE} == "" && ${JOB_ENABLE_GL} == "1" ) ]]; then - BUILD_OPENGL_TEST="ON" -fi - -if [[ ${JOB_ENABLE_DEBUG} == 1 ]]; then - BUILD_CONFIG="Debug" -else - BUILD_CONFIG="Release" -fi - -#Vulkan Headers -git clone https://github.com/KhronosGroup/Vulkan-Headers.git - -# Get and build loader -git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader.git -cd ${TOP}/OpenCL-ICD-Loader -mkdir build -cd build -cmake .. -G Ninja \ - -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ - -DOPENCL_ICD_LOADER_HEADERS_DIR=${TOP}/OpenCL-Headers/ \ - "${CMAKE_CONFIG_ARGS_ANDROID}" -cmake --build . --parallel - -#Vulkan Loader -if [[ ${JOB_ARCHITECTURE} != android-* ]]; then - # Building the Vulkan loader is not supported on Android, - # instead, the loader is shipped as part of the operating system - cd ${TOP} - git clone https://github.com/KhronosGroup/Vulkan-Loader.git - cd Vulkan-Loader - mkdir build - cd build - python3 ../scripts/update_deps.py - cmake .. -G Ninja \ - -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ - -DBUILD_WSI_XLIB_SUPPORT=OFF \ - -DBUILD_WSI_XCB_SUPPORT=OFF \ - -DBUILD_WSI_WAYLAND_SUPPORT=OFF \ - -C helper.cmake .. - cmake --build . --parallel -fi - -# Build CTS -cd ${TOP} -ls -l -mkdir build -cd build -if [[ ${RUNNER_OS} == "Windows" ]]; then - CMAKE_OPENCL_LIBRARIES_OPTION="OpenCL" -else - CMAKE_OPENCL_LIBRARIES_OPTION="-lOpenCL" - if [[ ${JOB_ARCHITECTURE} != android-* ]]; then - CMAKE_OPENCL_LIBRARIES_OPTION="${CMAKE_OPENCL_LIBRARIES_OPTION} -lpthread" - fi -fi -cmake .. -G Ninja \ - -DCMAKE_BUILD_TYPE="${BUILD_CONFIG}" \ - -DCMAKE_CACHE_OPTIONS="-DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache" \ - -DCL_INCLUDE_DIR=${TOP}/OpenCL-Headers \ - -DCL_LIB_DIR=${TOP}/OpenCL-ICD-Loader/build \ - -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ - -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=./bin \ - -DOPENCL_LIBRARIES="${CMAKE_OPENCL_LIBRARIES_OPTION}" \ - -DUSE_CL_EXPERIMENTAL=ON \ - -DGL_IS_SUPPORTED=${BUILD_OPENGL_TEST} \ - -DVULKAN_IS_SUPPORTED=${BUILD_VULKAN_TEST} \ - -DVULKAN_INCLUDE_DIR=${TOP}/Vulkan-Headers/include/ \ - -DVULKAN_LIB_DIR=${TOP}/Vulkan-Loader/build/loader/ \ - "${CMAKE_CONFIG_ARGS_ANDROID}" -cmake --build . --parallel diff --git a/test_common/gl/setup.h b/test_common/gl/setup.h index 6ee810bb..18cfee68 100644 --- a/test_common/gl/setup.h +++ b/test_common/gl/setup.h @@ -13,12 +13,13 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef _setup_h -#define _setup_h +#ifndef _gl_setup_h +#define _gl_setup_h #include #include #include +#include #include "gl_headers.h" #ifdef __APPLE__ #include @@ -36,13 +37,11 @@ class GLEnvironment GLEnvironment() {} virtual ~GLEnvironment() {} - virtual int Init( int *argc, char **argv, int use_opengl_32 ) = 0; + virtual int Init(int *argc, char **argv, int use_opengl_32) = 0; virtual cl_context CreateCLContext( void ) = 0; virtual int SupportsCLGLInterop( cl_device_type device_type) = 0; - static GLEnvironment * Instance( void ); - - + static GLEnvironment *Instance(void); }; -#endif // _setup_h +#endif // _gl_setup_h diff --git a/test_common/gl/setup_osx.cpp b/test_common/gl/setup_osx.cpp index 298f1a92..6d1b2e7d 100644 --- a/test_common/gl/setup_osx.cpp +++ b/test_common/gl/setup_osx.cpp @@ -1,6 +1,6 @@ // -// Copyright (c) 2017 The Khronos Group Inc. -// +// 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 @@ -25,65 +25,74 @@ private: public: OSXGLEnvironment() { - mCGLContext = NULL; mIsGlutInit = false; + mCGLContext = NULL; + mShareGroup = NULL; + mPlatform = NULL; } - virtual int Init( int *argc, char **argv, int use_opengl_32 ) + int Init(int *argc, char **argv, int use_opengl_32) override + { + if (!use_opengl_32) { - if (!use_opengl_32) { - if (!mIsGlutInit) - { - // Create a GLUT window to render into - glutInit(argc, argv); - glutInitWindowSize(512, 512); - glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); - glutCreateWindow("OpenCL <-> OpenGL Test"); - mIsGlutInit = true; - } - } - - else { - - CGLPixelFormatAttribute attribs[] = { - kCGLPFAOpenGLProfile, (CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core, - kCGLPFAAllowOfflineRenderers, - kCGLPFANoRecovery, - kCGLPFAAccelerated, - kCGLPFADoubleBuffer, - (CGLPixelFormatAttribute)0 - }; - - CGLError err; - CGLPixelFormatObj pix; - GLint npix; - err = CGLChoosePixelFormat (attribs, &pix, &npix); - if(err != kCGLNoError) - { - log_error("Failed to choose pixel format\n"); - return -1; - } - err = CGLCreateContext(pix, NULL, &mCGLContext); - if(err != kCGLNoError) - { - log_error("Failed to create GL context\n"); - return -1; - } - CGLSetCurrentContext(mCGLContext); - } - - return 0; + if (!mIsGlutInit) + { + // Create a GLUT window to render into + glutInit(argc, argv); + glutInitWindowSize(512, 512); + glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); + glutCreateWindow("OpenCL <-> OpenGL Test"); + mIsGlutInit = true; + } } - virtual cl_context CreateCLContext( void ) + else + { + + CGLPixelFormatAttribute attribs[] = { + kCGLPFAOpenGLProfile, + (CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core, + kCGLPFAAllowOfflineRenderers, + kCGLPFANoRecovery, + kCGLPFAAccelerated, + kCGLPFADoubleBuffer, + (CGLPixelFormatAttribute)0 + }; + + CGLError err; + CGLPixelFormatObj pix; + GLint npix; + err = CGLChoosePixelFormat(attribs, &pix, &npix); + if (err != kCGLNoError) + { + log_error("Failed to choose pixel format\n"); + return -1; + } + err = CGLCreateContext(pix, NULL, &mCGLContext); + if (err != kCGLNoError) + { + log_error("Failed to create GL context\n"); + return -1; + } + CGLSetCurrentContext(mCGLContext); + } + + return 0; + } + + cl_context CreateCLContext(void) override { int error; if( mCGLContext == NULL ) mCGLContext = CGLGetCurrentContext(); - CGLShareGroupObj share_group = CGLGetShareGroup(mCGLContext); - cl_context_properties properties[] = { CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)share_group, 0 }; + mShareGroup = CGLGetShareGroup(mCGLContext); + cl_context_properties properties[] = { + CL_CONTEXT_PLATFORM, (cl_context_properties)mPlatform, + CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, + (cl_context_properties)mShareGroup, 0 + }; cl_context context = clCreateContext(properties, 0, 0, 0, 0, &error); if (error) { print_error(error, "clCreateContext failed"); @@ -108,16 +117,24 @@ public: return context; } - virtual int SupportsCLGLInterop( cl_device_type device_type ) + int SupportsCLGLInterop(cl_device_type device_type) override { int found_valid_device = 0; cl_device_id devices[64]; cl_uint num_of_devices; int error; - error = clGetDeviceIDs(NULL, device_type, 64, devices, &num_of_devices); + error = clGetPlatformIDs(1, &mPlatform, NULL); + if (error) + { + print_error(error, "clGetPlatformIDs failed"); + return 0; + } + + error = + clGetDeviceIDs(mPlatform, device_type, 64, devices, &num_of_devices); if (error) { print_error(error, "clGetDeviceIDs failed"); - return -1; + return 0; } for (int i=0; i<(int)num_of_devices; i++) { @@ -131,13 +148,11 @@ public: return found_valid_device; } - virtual ~OSXGLEnvironment() - { - CGLDestroyContext( mCGLContext ); - } - - CGLContextObj mCGLContext; + virtual ~OSXGLEnvironment() { CGLDestroyContext(mCGLContext); } + CGLContextObj mCGLContext; + CGLShareGroupObj mShareGroup; + cl_platform_id mPlatform; }; GLEnvironment * GLEnvironment::Instance( void ) diff --git a/test_common/gl/setup_win32.cpp b/test_common/gl/setup_win32.cpp index 708e681d..d503695a 100644 --- a/test_common/gl/setup_win32.cpp +++ b/test_common/gl/setup_win32.cpp @@ -1,6 +1,6 @@ // -// Copyright (c) 2017 The Khronos Group Inc. -// +// 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 @@ -42,14 +42,19 @@ private: cl_platform_id m_platform; bool m_is_glut_init; + HGLRC m_hGLRC; + HDC m_hDC; + public: WGLEnvironment() { m_device_count = 0; m_platform = 0; m_is_glut_init = false; + m_hGLRC = 0; + m_hDC = 0; } - virtual int Init( int *argc, char **argv, int use_opengl_32 ) + int Init(int *argc, char **argv, int use_opengl_32) override { if (!m_is_glut_init) { @@ -64,21 +69,25 @@ public: return 0; } - virtual cl_context CreateCLContext( void ) + cl_context CreateCLContext(void) override { - HGLRC hGLRC = wglGetCurrentContext(); - HDC hDC = wglGetCurrentDC(); + m_hGLRC = wglGetCurrentContext(); + m_hDC = wglGetCurrentDC(); cl_context_properties properties[] = { - CL_CONTEXT_PLATFORM, (cl_context_properties) m_platform, - CL_GL_CONTEXT_KHR, (cl_context_properties) hGLRC, - CL_WGL_HDC_KHR, (cl_context_properties) hDC, + CL_CONTEXT_PLATFORM, + (cl_context_properties)m_platform, + CL_GL_CONTEXT_KHR, + (cl_context_properties)m_hGLRC, + CL_WGL_HDC_KHR, + (cl_context_properties)m_hDC, 0 }; cl_device_id devices[MAX_DEVICES]; size_t dev_size; cl_int status; - if (!hGLRC || !hDC) { + if (!m_hGLRC || !m_hDC) + { print_error(CL_INVALID_CONTEXT, "No GL context bound"); return 0; } @@ -155,7 +164,7 @@ public: return clCreateContext(properties, 1, &ctxDevice, NULL, NULL, &status); } - virtual int SupportsCLGLInterop( cl_device_type device_type ) + int SupportsCLGLInterop(cl_device_type device_type) override { cl_device_id devices[MAX_DEVICES]; cl_uint num_of_devices; diff --git a/test_common/gl/setup_x11.cpp b/test_common/gl/setup_x11.cpp index 3292902f..f06b8b23 100644 --- a/test_common/gl/setup_x11.cpp +++ b/test_common/gl/setup_x11.cpp @@ -28,13 +28,21 @@ private: cl_uint m_device_count; bool m_glut_init; + cl_platform_id m_platform; + GLXContext m_context; + Display *m_dpy; + public: X11GLEnvironment() { m_device_count = 0; m_glut_init = false; + m_platform = 0; + m_context = 0; + m_dpy = nullptr; } - virtual int Init( int *argc, char **argv, int use_opencl_32 ) + + int Init(int *argc, char **argv, int use_opencl_32) override { // Create a GLUT window to render into if (!m_glut_init) @@ -49,19 +57,24 @@ public: return 0; } - virtual cl_context CreateCLContext( void ) + cl_context CreateCLContext(void) override { - GLXContext context = glXGetCurrentContext(); - Display *dpy = glXGetCurrentDisplay(); + m_context = glXGetCurrentContext(); + m_dpy = glXGetCurrentDisplay(); cl_context_properties properties[] = { - CL_GL_CONTEXT_KHR, (cl_context_properties) context, - CL_GLX_DISPLAY_KHR, (cl_context_properties) dpy, + CL_CONTEXT_PLATFORM, + (cl_context_properties)m_platform, + CL_GL_CONTEXT_KHR, + (cl_context_properties)m_context, + CL_GLX_DISPLAY_KHR, + (cl_context_properties)m_dpy, 0 }; cl_int status; - if (!context || !dpy) { + if (!m_context || !m_dpy) + { print_error(CL_INVALID_CONTEXT, "No GL context bound"); return 0; } @@ -69,19 +82,19 @@ public: return clCreateContext(properties, 1, m_devices, NULL, NULL, &status); } - virtual int SupportsCLGLInterop( cl_device_type device_type ) + int SupportsCLGLInterop(cl_device_type device_type) override { int found_valid_device = 0; - cl_platform_id platform; cl_device_id devices[64]; cl_uint num_of_devices; int error; - error = clGetPlatformIDs(1, &platform, NULL); + error = clGetPlatformIDs(1, &m_platform, NULL); if (error) { print_error(error, "clGetPlatformIDs failed"); return -1; } - error = clGetDeviceIDs(platform, device_type, 64, devices, &num_of_devices); + error = clGetDeviceIDs(m_platform, device_type, 64, devices, + &num_of_devices); // If this platform doesn't have any of the requested device_type (namely GPUs) then return 0 if (error == CL_DEVICE_NOT_FOUND) return 0; diff --git a/test_common/harness/errorHelpers.cpp b/test_common/harness/errorHelpers.cpp index 287cb82e..fe65f0cc 100644 --- a/test_common/harness/errorHelpers.cpp +++ b/test_common/harness/errorHelpers.cpp @@ -213,6 +213,12 @@ const char *GetChannelTypeName(cl_channel_type type) case CL_UNORM_INT24: return "CL_UNORM_INT24"; case CL_UNSIGNED_INT_RAW10_EXT: return "CL_UNSIGNED_INT_RAW10_EXT"; case CL_UNSIGNED_INT_RAW12_EXT: return "CL_UNSIGNED_INT_RAW12_EXT"; + case CL_UNSIGNED_INT10X6_EXT: return "CL_UNSIGNED_INT10X6_EXT"; + case CL_UNSIGNED_INT12X4_EXT: return "CL_UNSIGNED_INT12X4_EXT"; + case CL_UNSIGNED_INT14X2_EXT: return "CL_UNSIGNED_INT14X2_EXT"; + case CL_UNORM_INT10X6_EXT: return "CL_UNORM_INT10X6_EXT"; + case CL_UNORM_INT12X4_EXT: return "CL_UNORM_INT12X4_EXT"; + case CL_UNORM_INT14X2_EXT: return "CL_UNORM_INT14X2_EXT"; default: return NULL; } } @@ -238,10 +244,16 @@ int IsChannelTypeSupported(cl_channel_type type) case CL_UNSIGNED_INT16: case CL_UNSIGNED_INT32: case CL_HALF_FLOAT: - case CL_FLOAT: return 1; + case CL_FLOAT: #ifdef CL_SFIXED14_APPLE - case CL_SFIXED14_APPLE: return 1; + case CL_SFIXED14_APPLE: #endif + case CL_UNSIGNED_INT10X6_EXT: + case CL_UNSIGNED_INT12X4_EXT: + case CL_UNSIGNED_INT14X2_EXT: + case CL_UNORM_INT10X6_EXT: + case CL_UNORM_INT12X4_EXT: + case CL_UNORM_INT14X2_EXT: return 1; default: return 0; } } diff --git a/test_common/harness/imageHelpers.cpp b/test_common/harness/imageHelpers.cpp index 3de7e948..6a990104 100644 --- a/test_common/harness/imageHelpers.cpp +++ b/test_common/harness/imageHelpers.cpp @@ -97,7 +97,13 @@ uint32_t get_channel_data_type_size(cl_channel_type channelType) case CL_UNSIGNED_INT32: return sizeof(cl_int); case CL_UNORM_SHORT_565: - case CL_UNORM_SHORT_555: return 2; + case CL_UNORM_SHORT_555: + case CL_UNSIGNED_INT10X6_EXT: + case CL_UNSIGNED_INT12X4_EXT: + case CL_UNSIGNED_INT14X2_EXT: + case CL_UNORM_INT10X6_EXT: + case CL_UNORM_INT12X4_EXT: + case CL_UNORM_INT14X2_EXT: return 2; case CL_UNORM_INT_101010: case CL_UNORM_INT_101010_2: @@ -186,6 +192,12 @@ cl_channel_type get_channel_type_from_name(const char *name) #ifdef CL_SFIXED14_APPLE { CL_SFIXED14_APPLE, "CL_SFIXED14_APPLE" } #endif + { CL_UNSIGNED_INT10X6_EXT, "CL_UNSIGNED_INT10X6_EXT" }, + { CL_UNSIGNED_INT12X4_EXT, "CL_UNSIGNED_INT12X4_EXT" }, + { CL_UNSIGNED_INT14X2_EXT, "CL_UNSIGNED_INT14X2_EXT" }, + { CL_UNORM_INT10X6_EXT, "CL_UNORM_INT10X6_EXT" }, + { CL_UNORM_INT12X4_EXT, "CL_UNORM_INT12X4_EXT" }, + { CL_UNORM_INT14X2_EXT, "CL_UNORM_INT14X2_EXT" }, }; for (size_t i = 0; i < sizeof(typeNames) / sizeof(typeNames[0]); i++) { @@ -278,6 +290,12 @@ uint32_t get_pixel_size(const cl_image_format *format) #ifdef CL_SFIXED14_APPLE case CL_SFIXED14_APPLE: #endif + case CL_UNSIGNED_INT10X6_EXT: + case CL_UNSIGNED_INT12X4_EXT: + case CL_UNSIGNED_INT14X2_EXT: + case CL_UNORM_INT10X6_EXT: + case CL_UNORM_INT12X4_EXT: + case CL_UNORM_INT14X2_EXT: return get_format_channel_count(format) * sizeof(cl_ushort); case CL_SIGNED_INT32: @@ -940,6 +958,9 @@ float get_max_absolute_error(const cl_image_format *format, #endif case CL_UNORM_SHORT_555: case CL_UNORM_SHORT_565: return 1.0f / 31.0f; + case CL_UNORM_INT10X6_EXT: return 1.0f / 1023.0f; + case CL_UNORM_INT12X4_EXT: return 1.0f / 4095.0f; + case CL_UNORM_INT14X2_EXT: return 1.0f / 16383.0f; default: return 0.0f; } } @@ -968,6 +989,9 @@ float get_max_relative_error(const cl_image_format *format, case CL_UNORM_INT_101010: case CL_UNORM_INT_101010_2: case CL_UNORM_INT_2_101010_EXT: + case CL_UNORM_INT10X6_EXT: + case CL_UNORM_INT12X4_EXT: + case CL_UNORM_INT14X2_EXT: // Maximum sampling error for round to zero normalization based on // multiplication by reciprocal (using reciprocal generated in // round to +inf mode, so that 1.0 matches spec) @@ -1053,7 +1077,15 @@ size_t get_format_max_int(const cl_image_format *format) case CL_UNORM_INT_101010: case CL_UNORM_INT_101010_2: - case CL_UNORM_INT_2_101010_EXT: return 1023; + case CL_UNORM_INT_2_101010_EXT: + case CL_UNSIGNED_INT10X6_EXT: + case CL_UNORM_INT10X6_EXT: return 1023; + + case CL_UNSIGNED_INT12X4_EXT: + case CL_UNORM_INT12X4_EXT: return 4095; + + case CL_UNSIGNED_INT14X2_EXT: + case CL_UNORM_INT14X2_EXT: return 16383; case CL_HALF_FLOAT: return 1 << 10; @@ -1087,7 +1119,13 @@ int get_format_min_int(const cl_image_format *format) case CL_UNORM_SHORT_555: case CL_UNORM_INT_101010: case CL_UNORM_INT_101010_2: - case CL_UNORM_INT_2_101010_EXT: return 0; + case CL_UNORM_INT_2_101010_EXT: + case CL_UNSIGNED_INT10X6_EXT: + case CL_UNSIGNED_INT12X4_EXT: + case CL_UNSIGNED_INT14X2_EXT: + case CL_UNORM_INT10X6_EXT: + case CL_UNORM_INT12X4_EXT: + case CL_UNORM_INT14X2_EXT: return 0; case CL_HALF_FLOAT: return -(1 << 10); @@ -1521,6 +1559,30 @@ void read_image_pixel_float(void *imageData, image_descriptor *imageInfo, int x, break; } + case CL_UNORM_INT10X6_EXT: { + cl_ushort *dPtr = (cl_ushort *)ptr; + for (i = 0; i < channelCount; i++) + tempData[i] = + CLAMP_FLOAT((float)((dPtr[i] >> 6) & 0x3ff) / 1023.0f); + break; + } + + case CL_UNORM_INT12X4_EXT: { + cl_ushort *dPtr = (cl_ushort *)ptr; + for (i = 0; i < channelCount; i++) + tempData[i] = + CLAMP_FLOAT((float)((dPtr[i] >> 4) & 0xfff) / 4095.0f); + break; + } + + case CL_UNORM_INT14X2_EXT: { + cl_ushort *dPtr = (cl_ushort *)ptr; + for (i = 0; i < channelCount; i++) + tempData[i] = + CLAMP_FLOAT((float)((dPtr[i] >> 2) & 0x3fff) / 16383.0f); + break; + } + case CL_FLOAT: { float *dPtr = (float *)ptr; for (i = 0; i < channelCount; i++) tempData[i] = (float)dPtr[i]; @@ -2634,6 +2696,24 @@ void pack_image_pixel(unsigned int *srcVector, ptr[i] = (unsigned int)srcVector[i]; break; } + case CL_UNSIGNED_INT10X6_EXT: { + unsigned short *ptr = (unsigned short *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = (unsigned short)SATURATE(srcVector[i], 0, 1023) << 6; + break; + } + case CL_UNSIGNED_INT12X4_EXT: { + unsigned short *ptr = (unsigned short *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = (unsigned short)SATURATE(srcVector[i], 0, 4095) << 4; + break; + } + case CL_UNSIGNED_INT14X2_EXT: { + unsigned short *ptr = (unsigned short *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = (unsigned short)SATURATE(srcVector[i], 0, 16383) << 2; + break; + } default: break; } } @@ -2809,6 +2889,27 @@ void pack_image_pixel(float *srcVector, const cl_image_format *imageFormat, | (((unsigned int)NORMALIZE(srcVector[3], 1023.f) & 1023) << 0); break; } + case CL_UNORM_INT10X6_EXT: { + cl_ushort *ptr = (cl_ushort *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = ((cl_ushort)NORMALIZE(srcVector[i], 1023.f) & 1023) + << 6; + break; + } + case CL_UNORM_INT12X4_EXT: { + cl_ushort *ptr = (cl_ushort *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = ((cl_ushort)NORMALIZE(srcVector[i], 4095.f) & 4095) + << 4; + break; + } + case CL_UNORM_INT14X2_EXT: { + cl_ushort *ptr = (cl_ushort *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = ((cl_ushort)NORMALIZE(srcVector[i], 16383.f) & 16383) + << 2; + break; + } case CL_SIGNED_INT8: { cl_char *ptr = (cl_char *)outData; for (unsigned int i = 0; i < channelCount; i++) @@ -2852,6 +2953,27 @@ void pack_image_pixel(float *srcVector, const cl_image_format *imageFormat, CL_UINT_MAX); break; } + case CL_UNSIGNED_INT10X6_EXT: { + cl_ushort *ptr = (cl_ushort *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = ((cl_ushort)NORMALIZE(srcVector[i], 1023.f) & 1023) + << 6; + break; + } + case CL_UNSIGNED_INT12X4_EXT: { + cl_ushort *ptr = (cl_ushort *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = ((cl_ushort)NORMALIZE(srcVector[i], 4095.f) & 4095) + << 4; + break; + } + case CL_UNSIGNED_INT14X2_EXT: { + cl_ushort *ptr = (cl_ushort *)outData; + for (unsigned int i = 0; i < channelCount; i++) + ptr[i] = ((cl_ushort)NORMALIZE(srcVector[i], 16383.f) & 16383) + << 2; + break; + } #ifdef CL_SFIXED14_APPLE case CL_SFIXED14_APPLE: { cl_ushort *ptr = (cl_ushort *)outData; @@ -2999,6 +3121,33 @@ void pack_image_pixel_error(const float *srcVector, break; } + case CL_UNORM_INT10X6_EXT: { + const cl_ushort *ptr = (const cl_ushort *)results; + + for (unsigned int i = 0; i < channelCount; i++) + errors[i] = + (ptr[i] >> 6) - NORMALIZE_UNROUNDED(srcVector[i], 1023.f); + + break; + } + case CL_UNORM_INT12X4_EXT: { + const cl_ushort *ptr = (const cl_ushort *)results; + + for (unsigned int i = 0; i < channelCount; i++) + errors[i] = + (ptr[i] >> 4) - NORMALIZE_UNROUNDED(srcVector[i], 4095.f); + + break; + } + case CL_UNORM_INT14X2_EXT: { + const cl_ushort *ptr = (const cl_ushort *)results; + + for (unsigned int i = 0; i < channelCount; i++) + errors[i] = + (ptr[i] >> 2) - NORMALIZE_UNROUNDED(srcVector[i], 16383.f); + + break; + } case CL_SIGNED_INT8: { const cl_char *ptr = (const cl_char *)results; @@ -3050,6 +3199,29 @@ void pack_image_pixel_error(const float *srcVector, CL_UINT_MAX)); break; } + case CL_UNSIGNED_INT10X6_EXT: { + cl_ushort *ptr = (cl_ushort *)results; + for (unsigned int i = 0; i < channelCount; i++) + errors[i] = static_cast( + (cl_int)ptr[i] - (*((cl_int *)(&srcVector[i])) & 0xffc0)); + break; + } + case CL_UNSIGNED_INT12X4_EXT: { + cl_ushort *ptr = (cl_ushort *)results; + for (unsigned int i = 0; i < channelCount; i++) + errors[i] = static_cast( + (cl_int)ptr[i] - (*((cl_int *)(&srcVector[i])) & 0xfff0)); + break; + } + case CL_UNSIGNED_INT14X2_EXT: { + cl_ushort *ptr = (cl_ushort *)results; + for (unsigned int i = 0; i < channelCount; i++) + errors[i] = static_cast( + (cl_int)ptr[i] + - (cl_int)CONVERT_UINT(srcVector[i], 16383.f, + CL_USHRT_MAX)); + break; + } #ifdef CL_SFIXED14_APPLE case CL_SFIXED14_APPLE: { const cl_ushort *ptr = (const cl_ushort *)results; diff --git a/test_common/harness/imageHelpers.h b/test_common/harness/imageHelpers.h index d49f358e..a55c17b5 100644 --- a/test_common/harness/imageHelpers.h +++ b/test_common/harness/imageHelpers.h @@ -126,6 +126,7 @@ typedef struct const cl_image_format *format; cl_mem buffer; cl_mem_object_type type; + cl_mem_flags mem_flags; cl_uint num_mip_levels; } image_descriptor; @@ -447,6 +448,27 @@ void read_image_pixel(void *imageData, image_descriptor *imageInfo, int x, tempData[0] = (T)(hi_val | lo_val); break; } + case CL_UNSIGNED_INT10X6_EXT: { + cl_short *dPtr = (cl_short *)ptr; + const size_t channelCount = get_format_channel_count(format); + for (i = 0; i < channelCount; i++) + tempData[i] = (dPtr[i] >> 6) & 0x3ff; + break; + } + case CL_UNSIGNED_INT12X4_EXT: { + cl_short *dPtr = (cl_short *)ptr; + const size_t channelCount = get_format_channel_count(format); + for (i = 0; i < channelCount; i++) + tempData[i] = (dPtr[i] >> 4) & 0xfff; + break; + } + case CL_UNSIGNED_INT14X2_EXT: { + cl_short *dPtr = (cl_short *)ptr; + const size_t channelCount = get_format_channel_count(format); + for (i = 0; i < channelCount; i++) + tempData[i] = (dPtr[i] >> 2) & 0x3fff; + break; + } } diff --git a/test_common/harness/kernelHelpers.cpp b/test_common/harness/kernelHelpers.cpp index 8e41fbdd..8fa9c0a4 100644 --- a/test_common/harness/kernelHelpers.cpp +++ b/test_common/harness/kernelHelpers.cpp @@ -1328,6 +1328,12 @@ size_t get_pixel_bytes(const cl_image_format *fmt) case CL_SIGNED_INT8: case CL_UNSIGNED_INT8: return chanCount; + case CL_UNSIGNED_INT10X6_EXT: + case CL_UNSIGNED_INT12X4_EXT: + case CL_UNSIGNED_INT14X2_EXT: + case CL_UNORM_INT10X6_EXT: + case CL_UNORM_INT12X4_EXT: + case CL_UNORM_INT14X2_EXT: case CL_SNORM_INT16: case CL_UNORM_INT16: case CL_HALF_FLOAT: diff --git a/test_common/harness/typeWrappers.h b/test_common/harness/typeWrappers.h index ad11b480..ef57f6d7 100644 --- a/test_common/harness/typeWrappers.h +++ b/test_common/harness/typeWrappers.h @@ -377,4 +377,24 @@ public: size_t getSize() const { return allocsize; }; }; +// scope guard helper to ensure proper releasing of sub devices +struct SubDevicesScopeGuarded +{ + SubDevicesScopeGuarded(const cl_int dev_count) + { + sub_devices.resize(dev_count); + } + ~SubDevicesScopeGuarded() + { + for (auto &device : sub_devices) + { + cl_int err = clReleaseDevice(device); + if (err != CL_SUCCESS) + log_error("\n Releasing sub-device failed \n"); + } + } + + std::vector sub_devices; +}; + #endif // _typeWrappers_h diff --git a/test_conformance/allocations/main.cpp b/test_conformance/allocations/main.cpp index e0310bb8..b62c2a54 100644 --- a/test_conformance/allocations/main.cpp +++ b/test_conformance/allocations/main.cpp @@ -26,6 +26,8 @@ typedef long long unsigned llu; #define REDUCTION_PERCENTAGE_DEFAULT 50 +#define BYTES_PER_WORK_ITEM 2048ULL + int g_repetition_count = 1; int g_reduction_percentage = REDUCTION_PERCENTAGE_DEFAULT; int g_write_allocations = 1; @@ -125,7 +127,7 @@ int doTest(cl_device_id device, cl_context context, cl_command_queue queue, int number_of_mems_used; cl_ulong max_individual_allocation_size = g_max_individual_allocation_size; cl_ulong global_mem_size = g_global_mem_size; - unsigned int number_of_work_items = 8192 * 32; + unsigned int number_of_work_items; const bool allocate_image = (alloc_type != BUFFER) && (alloc_type != BUFFER_NON_BLOCKING); @@ -183,12 +185,16 @@ int doTest(cl_device_id device, cl_context context, cl_command_queue queue, g_reduction_percentage); g_max_size = (size_t)((double)g_max_size * (double)g_reduction_percentage / 100.0); - number_of_work_items = 8192 * 2; } // Round to nearest MB. g_max_size &= (size_t)(0xFFFFFFFFFF00000ULL); + // Scales the number of work-items to keep the amount of bytes processed + // per work-item the same. + number_of_work_items = + std::max(g_max_size / BYTES_PER_WORK_ITEM, 8192ULL * 2ULL); + log_info("** Target allocation size (rounded to nearest MB) is: %llu bytes " "(%gMB).\n", llu(g_max_size), toMB(g_max_size)); diff --git a/test_conformance/api/CMakeLists.txt b/test_conformance/api/CMakeLists.txt index 3df9a81f..f2bfac35 100644 --- a/test_conformance/api/CMakeLists.txt +++ b/test_conformance/api/CMakeLists.txt @@ -4,6 +4,7 @@ set(${MODULE_NAME}_SOURCES main.cpp negative_platform.cpp negative_queue.cpp + negative_enqueue_map_image.cpp test_api_consistency.cpp test_bool.cpp test_retain.cpp diff --git a/test_conformance/api/negative_enqueue_map_image.cpp b/test_conformance/api/negative_enqueue_map_image.cpp new file mode 100644 index 00000000..95542163 --- /dev/null +++ b/test_conformance/api/negative_enqueue_map_image.cpp @@ -0,0 +1,191 @@ +// +// 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 "testBase.h" +#include "harness/clImageHelper.h" + +#include +#include +#include + +static constexpr cl_mem_object_type image_types[] = { + CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D, CL_MEM_OBJECT_IMAGE2D_ARRAY, + CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY +}; + +REGISTER_TEST(negative_enqueue_map_image) +{ + constexpr size_t image_dim = 32; + + REQUIRE_EXTENSION("cl_ext_immutable_memory_objects"); + + static constexpr cl_mem_flags mem_flags[]{ + CL_MEM_IMMUTABLE_EXT | CL_MEM_USE_HOST_PTR, + CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, + CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR | CL_MEM_ALLOC_HOST_PTR + }; + + static constexpr const char *mem_flags_string[]{ + "CL_MEM_IMMUTABLE_EXT | CL_MEM_USE_HOST_PTR", + "CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR", + "CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR | " + "CL_MEM_ALLOC_HOST_PTR" + }; + + static_assert(ARRAY_SIZE(mem_flags) == ARRAY_SIZE(mem_flags_string), + "mem_flags and mem_flags_string must be of the same size"); + + using CLUCharPtr = std::unique_ptr; + + for (size_t index = 0; index < ARRAY_SIZE(mem_flags); ++index) + { + cl_mem_flags mem_flag = mem_flags[index]; + + log_info("Testing memory flag: %s\n", mem_flags_string[index]); + for (cl_mem_object_type image_type : image_types) + { + // find supported image formats + cl_uint num_formats = 0; + + cl_int error = clGetSupportedImageFormats( + context, mem_flag, image_type, 0, nullptr, &num_formats); + test_error(error, + "clGetSupportedImageFormats failed to return supported " + "formats"); + + std::vector formats(num_formats); + error = clGetSupportedImageFormats(context, mem_flag, image_type, + num_formats, formats.data(), + nullptr); + test_error(error, + "clGetSupportedImageFormats failed to return supported " + "formats"); + + clMemWrapper image; + for (cl_image_format &fmt : formats) + { + log_info("Testing %s %s\n", + GetChannelOrderName(fmt.image_channel_order), + GetChannelTypeName(fmt.image_channel_data_type)); + + RandomSeed seed(gRandomSeed); + size_t origin[3] = { 0, 0, 0 }; + size_t region[3] = { image_dim, image_dim, image_dim }; + switch (image_type) + { + case CL_MEM_OBJECT_IMAGE1D: { + const size_t pixel_size = get_pixel_size(&fmt); + const size_t image_size = + image_dim * pixel_size * sizeof(cl_uchar); + CLUCharPtr imgptr{ static_cast( + create_random_data(kUChar, seed, + image_size)), + free }; + image = + create_image_1d(context, mem_flag, &fmt, image_dim, + 0, imgptr.get(), nullptr, &error); + region[1] = 1; + region[2] = 1; + break; + } + case CL_MEM_OBJECT_IMAGE2D: { + const size_t pixel_size = get_pixel_size(&fmt); + const size_t image_size = image_dim * image_dim + * pixel_size * sizeof(cl_uchar); + CLUCharPtr imgptr{ static_cast( + create_random_data(kUChar, seed, + image_size)), + free }; + image = + create_image_2d(context, mem_flag, &fmt, image_dim, + image_dim, 0, imgptr.get(), &error); + region[2] = 1; + break; + } + case CL_MEM_OBJECT_IMAGE3D: { + const size_t pixel_size = get_pixel_size(&fmt); + const size_t image_size = image_dim * image_dim + * image_dim * pixel_size * sizeof(cl_uchar); + CLUCharPtr imgptr{ static_cast( + create_random_data(kUChar, seed, + image_size)), + free }; + image = create_image_3d(context, mem_flag, &fmt, + image_dim, image_dim, image_dim, + 0, 0, imgptr.get(), &error); + break; + } + case CL_MEM_OBJECT_IMAGE1D_ARRAY: { + const size_t pixel_size = get_pixel_size(&fmt); + const size_t image_size = image_dim * image_dim + * pixel_size * sizeof(cl_uchar); + CLUCharPtr imgptr{ static_cast( + create_random_data(kUChar, seed, + image_size)), + free }; + image = create_image_1d_array(context, mem_flag, &fmt, + image_dim, image_dim, 0, + 0, imgptr.get(), &error); + region[1] = 1; + region[2] = 1; + break; + } + case CL_MEM_OBJECT_IMAGE2D_ARRAY: { + const size_t pixel_size = get_pixel_size(&fmt); + const size_t image_size = image_dim * image_dim + * image_dim * pixel_size * sizeof(cl_uchar); + CLUCharPtr imgptr{ static_cast( + create_random_data(kUChar, seed, + image_size)), + free }; + image = create_image_2d_array( + context, mem_flag, &fmt, image_dim, image_dim, + image_dim, 0, 0, imgptr.get(), &error); + region[2] = 1; + break; + } + } + test_error(error, "Failed to create image"); + + void *map = clEnqueueMapImage( + queue, image, CL_TRUE, CL_MAP_WRITE, origin, region, + nullptr, nullptr, 0, nullptr, nullptr, &error); + + constexpr const char *write_err_msg = + "clEnqueueMapImage should return CL_INVALID_OPERATION " + "when: \"image has been created with CL_MEM_IMMUTABLE_EXT " + "and CL_MAP_WRITE is set in map_flags\""; + test_assert_error(map == nullptr, write_err_msg); + test_failure_error_ret(error, CL_INVALID_OPERATION, + write_err_msg, TEST_FAIL); + + map = clEnqueueMapImage(queue, image, CL_TRUE, + CL_MAP_WRITE_INVALIDATE_REGION, origin, + region, nullptr, nullptr, 0, nullptr, + nullptr, &error); + + constexpr const char *write_invalidate_err_msg = + "clEnqueueMapImage should return CL_INVALID_OPERATION " + "when: \"image has been created with CL_MEM_IMMUTABLE_EXT " + "and CL_MAP_WRITE_INVALIDATE_REGION is set in map_flags\""; + test_assert_error(map == nullptr, write_invalidate_err_msg); + test_failure_error_ret(error, CL_INVALID_OPERATION, + write_invalidate_err_msg, TEST_FAIL); + } + } + } + + return TEST_PASS; +} diff --git a/test_conformance/api/testBase.h b/test_conformance/api/testBase.h index beb3c924..02f76e94 100644 --- a/test_conformance/api/testBase.h +++ b/test_conformance/api/testBase.h @@ -27,24 +27,4 @@ #include #include -// scope guard helper to ensure proper releasing of sub devices -struct SubDevicesScopeGuarded -{ - SubDevicesScopeGuarded(const cl_int dev_count) - { - sub_devices.resize(dev_count); - } - ~SubDevicesScopeGuarded() - { - for (auto &device : sub_devices) - { - cl_int err = clReleaseDevice(device); - if (err != CL_SUCCESS) - log_error("\n Releasing sub-device failed \n"); - } - } - - std::vector sub_devices; -}; - #endif // _testBase_h diff --git a/test_conformance/api/test_api_consistency.cpp b/test_conformance/api/test_api_consistency.cpp index a859a701..cb39b3a8 100644 --- a/test_conformance/api/test_api_consistency.cpp +++ b/test_conformance/api/test_api_consistency.cpp @@ -1243,13 +1243,6 @@ REGISTER_TEST(consistency_requirements_fp16) } else { - error = clGetDeviceInfo(device, CL_DEVICE_HALF_FP_CONFIG, sizeof(value), - &value, nullptr); - test_failure_error( - error, CL_INVALID_VALUE, - "cl_khr_fp16 is not available; CL_DEVICE_HALF_FP_CONFIG must fail " - "with CL_INVALID_VALUE"); - error = clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, sizeof(value), &value, nullptr); test_error( diff --git a/test_conformance/api/test_kernel_local_memory_size.cpp b/test_conformance/api/test_kernel_local_memory_size.cpp index 7dcf3846..e75e6067 100644 --- a/test_conformance/api/test_kernel_local_memory_size.cpp +++ b/test_conformance/api/test_kernel_local_memory_size.cpp @@ -153,6 +153,8 @@ REGISTER_TEST(kernel_local_memory_size) "kernel local mem size failed"); + program.reset(); + kernel.reset(); // Check memory needed to execute empty kernel with __local parameter with // setKernelArg if (create_single_kernel_helper(context, &program, &kernel, 1, @@ -225,6 +227,8 @@ REGISTER_TEST(kernel_local_memory_size) "kernel local mem size failed"); + program.reset(); + kernel.reset(); // Check memory needed to execute kernel with __local variable and __local // parameter with setKernelArg if (create_single_kernel_helper(context, &program, &kernel, 1, diff --git a/test_conformance/api/test_kernels.cpp b/test_conformance/api/test_kernels.cpp index 2b5e9c56..30452caa 100644 --- a/test_conformance/api/test_kernels.cpp +++ b/test_conformance/api/test_kernels.cpp @@ -16,6 +16,7 @@ #include "testBase.h" #include "harness/typeWrappers.h" #include "harness/conversions.h" +#include const char *sample_single_test_kernel[] = { "__kernel void sample_test(__global float *src, __global int *dst)\n" @@ -49,6 +50,17 @@ const char *sample_const_test_kernel[] = { "\n" "}\n" }; +const char *sample_image_test_kernel[] = { + "__kernel void sample_image_test(__read_only image2d_t src, __write_only " + "image2d_t dst)\n" + "{\n" + " int2 coord = (int2)(get_global_id(0), get_global_id(1));\n" + " uint4 value = read_imageui(src, coord);\n" + " write_imageui(dst, coord, value);\n" + "\n" + "}\n" +}; + const char *sample_const_global_test_kernel[] = { "__constant int addFactor = 1024;\n" "__kernel void sample_test(__global int *src1, __global int *dst)\n" @@ -631,3 +643,64 @@ REGISTER_TEST(kernel_global_constant) return 0; } + +REGISTER_TEST(negative_set_immutable_memory_to_writeable_kernel_arg) +{ + REQUIRE_EXTENSION("cl_ext_immutable_memory_objects"); + + cl_int error = CL_SUCCESS; + clProgramWrapper program; + clKernelWrapper kernels[2]; + clMemWrapper image, buffer; + const char *test_kernels[2] = { sample_const_test_kernel[0], + sample_image_test_kernel[0] }; + constexpr cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 }; + constexpr size_t size_dim = 128; + + // Setup the test + error = create_single_kernel_helper(context, &program, nullptr, 2, + test_kernels, nullptr); + test_error(error, "Unable to build test program"); + + kernels[0] = clCreateKernel(program, "sample_test", &error); + test_error(error, "Unable to get sample_test kernel for built program"); + + kernels[1] = clCreateKernel(program, "sample_image_test", &error); + test_error(error, + "Unable to get sample_image_test kernel for built program"); + + std::vector mem_data(size_dim * size_dim); + buffer = clCreateBuffer(context, CL_MEM_IMMUTABLE_EXT | CL_MEM_USE_HOST_PTR, + sizeof(cl_int) * size_dim, mem_data.data(), &error); + test_error(error, "clCreateBuffer failed"); + + image = create_image_2d(context, CL_MEM_IMMUTABLE_EXT | CL_MEM_USE_HOST_PTR, + &formats, size_dim, size_dim, 0, mem_data.data(), + &error); + test_error(error, "create_image_2d failed"); + + // Run the test + error = clSetKernelArg(kernels[0], 0, sizeof(buffer), &buffer); + test_error(error, "clSetKernelArg failed"); + + error = clSetKernelArg(kernels[0], 2, sizeof(buffer), &buffer); + test_failure_error_ret(error, CL_INVALID_ARG_VALUE, + "clSetKernelArg is supposed to fail " + "with CL_INVALID_ARG_VALUE when a buffer is " + "created with CL_MEM_IMMUTABLE_EXT is " + "passed to a non-constant kernel argument", + TEST_FAIL); + + error = clSetKernelArg(kernels[1], 0, sizeof(image), &image); + test_error(error, "clSetKernelArg failed"); + + error = clSetKernelArg(kernels[1], 1, sizeof(image), &image); + test_failure_error_ret(error, CL_INVALID_ARG_VALUE, + "clSetKernelArg is supposed to fail " + "with CL_INVALID_ARG_VALUE when an image is " + "created with CL_MEM_IMMUTABLE_EXT is " + "passed to a write_only kernel argument", + TEST_FAIL); + + return TEST_PASS; +} diff --git a/test_conformance/api/test_queries.cpp b/test_conformance/api/test_queries.cpp index 81b99495..d104a133 100644 --- a/test_conformance/api/test_queries.cpp +++ b/test_conformance/api/test_queries.cpp @@ -796,6 +796,60 @@ REGISTER_TEST(get_device_info) return 0; } +REGISTER_TEST(get_device_info_comparability) +{ + int error = CL_SUCCESS; + + // comparability test for CL_DEVICE_PLATFORM + // 1. find platform related to device without using query + cl_uint num_platforms = 0; + error = clGetPlatformIDs(16, nullptr, &num_platforms); + test_error(error, "clGetPlatformIDs failed"); + + std::vector platforms(num_platforms); + + error = clGetPlatformIDs(num_platforms, platforms.data(), &num_platforms); + test_error(error, "clGetPlatformIDs failed"); + + cl_uint num_devices = 0; + cl_platform_id comp_platform = nullptr; + for (int p = 0; p < (int)num_platforms && comp_platform == nullptr; p++) + { + error = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, 0, nullptr, + &num_devices); + if (error != CL_SUCCESS || num_devices == 0) continue; + + std::vector devices(num_devices); + error = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, num_devices, + devices.data(), nullptr); + if (error != CL_SUCCESS) continue; + + // find correct device + for (auto did : devices) + { + if (did == device) + { + comp_platform = platforms[p]; + break; + } + } + } + + test_error_fail(comp_platform == nullptr, + "Test failed to locate platform for comparison!"); + + // 2. compare platforms found with and without using query + cl_platform_id plat = nullptr; + error = + clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(plat), &plat, NULL); + test_error(error, "clGetDeviceInfo failed"); + + test_assert_error(plat == comp_platform, + "Unexpected result returned by clGetDeviceInfo for " + "CL_DEVICE_PLATFORM query"); + + return TEST_PASS; +} static const char *sample_compile_size[2] = { "__kernel void sample_test(__global int *src, __global int *dst)\n" diff --git a/test_conformance/api/test_queue.cpp b/test_conformance/api/test_queue.cpp index 0d0fa13d..d3b713fb 100644 --- a/test_conformance/api/test_queue.cpp +++ b/test_conformance/api/test_queue.cpp @@ -23,7 +23,8 @@ REGISTER_TEST(queue_flush_on_release) cl_int err; // Create a command queue - cl_command_queue cmd_queue = clCreateCommandQueue(context, device, 0, &err); + clCommandQueueWrapper cmd_queue = + clCreateCommandQueue(context, device, 0, &err); test_error(err, "Could not create command queue"); // Create a kernel @@ -42,7 +43,7 @@ REGISTER_TEST(queue_flush_on_release) test_error(err, "Could not enqueue kernel"); // Release the queue - err = clReleaseCommandQueue(cmd_queue); + cmd_queue.reset(); // Wait for kernel to execute since the queue must flush on release bool success = poll_until(2000, 50, [&event]() { @@ -64,11 +65,13 @@ REGISTER_TEST(multi_queue_flush_on_release) cl_int err; // Create A command queue - cl_command_queue queue_A = clCreateCommandQueue(context, device, 0, &err); + clCommandQueueWrapper queue_A = + clCreateCommandQueue(context, device, 0, &err); test_error(err, "Could not create command queue A"); // Create B command queue - cl_command_queue queue_B = clCreateCommandQueue(context, device, 0, &err); + clCommandQueueWrapper queue_B = + clCreateCommandQueue(context, device, 0, &err); test_error(err, "Could not create command queue B"); // Create a kernel @@ -96,8 +99,7 @@ REGISTER_TEST(multi_queue_flush_on_release) // Release queue_A, which performs an implicit flush to issue any previously // queued OpenCL commands - err = clReleaseCommandQueue(queue_A); - test_error(err, "clReleaseCommandQueue failed"); + queue_A.reset(); err = clFlush(queue_B); test_error(err, "clFlush failed"); diff --git a/test_conformance/api/test_zero_sized_enqueue.cpp b/test_conformance/api/test_zero_sized_enqueue.cpp index 52b6f4a8..446b1900 100644 --- a/test_conformance/api/test_zero_sized_enqueue.cpp +++ b/test_conformance/api/test_zero_sized_enqueue.cpp @@ -1,6 +1,6 @@ // -// Copyright (c) 2017 The Khronos Group Inc. -// +// Copyright (c) 2017-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 @@ -14,18 +14,14 @@ // limitations under the License. // #include "testBase.h" -#include "harness/typeWrappers.h" -#include "harness/conversions.h" -const char* zero_sized_enqueue_test_kernel[] = { - "__kernel void foo_kernel(__global int *dst)\n" - "{\n" - " int tid = get_global_id(0);\n" - "\n" - " dst[tid] = 1;\n" - "\n" - "}\n" -}; +const char* zero_sized_enqueue_test_kernel = R"( +__kernel void foo_kernel(__global int *dst) +{ + int tid = get_global_id(0); + dst[tid] = 1; +} +)"; const int bufSize = 128; @@ -81,15 +77,20 @@ int test_zero_sized_enqueue_helper(cl_device_id device, cl_context context, output_stream = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, bufSize * sizeof(int), NULL, &error); + test_error(error, "clCreateBuffer failed."); // Initialise output buffer. int output_buffer_data = 0; error = clEnqueueFillBuffer(queue, output_stream, &output_buffer_data, sizeof(int), 0, sizeof(int) * bufSize, 0, NULL, NULL); + test_error(error, "clEnqueueFillBuffer failed."); /* Create a kernel to test with */ - if( create_single_kernel_helper( context, &program, &kernel, 1, zero_sized_enqueue_test_kernel, "foo_kernel" ) != 0 ) + if (create_single_kernel_helper(context, &program, &kernel, 1, + &zero_sized_enqueue_test_kernel, + "foo_kernel") + != 0) { return -1; } @@ -98,6 +99,16 @@ int test_zero_sized_enqueue_helper(cl_device_id device, cl_context context, test_error( error, "clSetKernelArg failed." ); // Simple API return code tests for 1D, 2D and 3D zero sized ND range. + error = test_zero_sized_enqueue_and_test_output_buffer( + queue, kernel, output_stream, 1, nullptr); + test_error(error, "1D null sized kernel enqueue failed."); + error = test_zero_sized_enqueue_and_test_output_buffer( + queue, kernel, output_stream, 2, nullptr); + test_error(error, "2D null sized kernel enqueue failed."); + error = test_zero_sized_enqueue_and_test_output_buffer( + queue, kernel, output_stream, 3, nullptr); + test_error(error, "3D null sized kernel enqueue failed."); + error = test_zero_sized_enqueue_and_test_output_buffer( queue, kernel, output_stream, 1, &ndrange1); test_error( error, "1D zero sized kernel enqueue failed." ); @@ -156,6 +167,17 @@ int test_zero_sized_enqueue_helper(cl_device_id device, cl_context context, return -1; } + cl_command_type cmdtype; + error = clGetEventInfo(ev, CL_EVENT_COMMAND_TYPE, sizeof(cmdtype), &cmdtype, + NULL); + test_error(error, "Failed to get event command type."); + if (cmdtype != CL_COMMAND_NDRANGE_KERNEL) + { + log_error( + "ERROR: incorrect zero sized kernel enqueue event command type.\n"); + return -1; + } + cl_int sta; error = clGetEventInfo(ev, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(cl_int), &sta, NULL); test_error( error, "Failed to get event status."); diff --git a/test_conformance/basic/CMakeLists.txt b/test_conformance/basic/CMakeLists.txt index a2b47402..7292bc9d 100644 --- a/test_conformance/basic/CMakeLists.txt +++ b/test_conformance/basic/CMakeLists.txt @@ -71,6 +71,6 @@ if(APPLE) list(APPEND ${MODULE_NAME}_SOURCES test_queue_priority.cpp) endif(APPLE) -set_gnulike_module_compile_flags("-Wno-sign-compare -Wno-format") +set_gnulike_module_compile_flags("-Wno-sign-compare") include(../CMakeCommon.txt) diff --git a/test_conformance/basic/test_arrayreadwrite.cpp b/test_conformance/basic/test_arrayreadwrite.cpp index ac2c2d7e..fe4bb995 100644 --- a/test_conformance/basic/test_arrayreadwrite.cpp +++ b/test_conformance/basic/test_arrayreadwrite.cpp @@ -20,31 +20,42 @@ #include #include #include +#include #include "testBase.h" -REGISTER_TEST(arrayreadwrite) +static int test_arrayreadwrite_impl(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements, + cl_mem_flags flags) { - cl_uint *inptr, *outptr; - cl_mem streams[1]; + clMemWrapper buffer; int num_tries = 400; num_elements = 1024 * 1024 * 4; - int i, j, err; - MTdata d; + MTdataHolder d(gRandomSeed); - inptr = (cl_uint*)malloc(num_elements*sizeof(cl_uint)); - outptr = (cl_uint*)malloc(num_elements*sizeof(cl_uint)); + std::vector reference_vals(num_elements); + std::vector inptr(num_elements); + std::vector outptr(num_elements); // randomize data - d = init_genrand( gRandomSeed ); - for (i=0; i (num_elements - offset)) cb = num_elements - offset; - err = clEnqueueWriteBuffer(queue, streams[0], CL_TRUE, offset*sizeof(cl_uint), sizeof(cl_uint)*cb,&inptr[offset], 0, NULL, NULL); + err = clEnqueueWriteBuffer( + queue, buffer, CL_TRUE, offset * sizeof(cl_uint), + sizeof(cl_uint) * cb, &reference_vals[offset], 0, nullptr, nullptr); test_error(err, "clEnqueueWriteBuffer failed"); - err = clEnqueueReadBuffer( queue, streams[0], CL_TRUE, offset*sizeof(cl_uint), cb*sizeof(cl_uint), &outptr[offset], 0, NULL, NULL ); + err = clEnqueueReadBuffer( + queue, buffer, CL_TRUE, offset * sizeof(cl_uint), + cb * sizeof(cl_uint), &outptr[offset], 0, nullptr, nullptr); test_error(err, "clEnqueueReadBuffer failed"); - for (j=offset; j #include +#include + #include "testBase.h" #define CL_EXIT_ERROR(cmd,format,...) \ @@ -340,8 +342,21 @@ void CL_CALLBACK mem_obj_destructor_callback( cl_mem, void *data ) free( data ); } -// This is the main test function for the conformance test. -REGISTER_TEST(bufferreadwriterect) +using test_fn = int (*)(size_t, size_t[3], size_t[3], size_t, size_t[3], + size_t[3]); +struct TestFunctions +{ + test_fn copy; + test_fn read; + test_fn write; +}; + +static int test_bufferreadwriterect_impl(cl_device_id device, + cl_context context, + cl_command_queue queue, + int num_elements, + cl_map_flags buffer_flags, + const TestFunctions& test_functions) { gQueue = queue; cl_int err; @@ -352,7 +367,8 @@ REGISTER_TEST(bufferreadwriterect) // Compute a maximum buffer size based on the number of test images and the device maximum. cl_ulong max_mem_alloc_size = 0; CL_EXIT_ERROR(clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &max_mem_alloc_size, NULL),"Could not get device info"); - log_info("CL_DEVICE_MAX_MEM_ALLOC_SIZE = %llu bytes.\n", max_mem_alloc_size); + log_info("CL_DEVICE_MAX_MEM_ALLOC_SIZE = %" PRIu64 " bytes.\n", + max_mem_alloc_size); // Confirm that the maximum allocation size is not zero. if (max_mem_alloc_size == 0) { @@ -390,7 +406,7 @@ REGISTER_TEST(bufferreadwriterect) // Check to see if adequately sized buffers were found. if (tries >= max_tries) { log_error("Error: Could not find random buffer sized less than " - "%llu bytes in %zu tries.\n", + "%" PRIu64 " bytes in %zu tries.\n", max_mem_alloc_size, max_tries); return -1; } @@ -431,7 +447,8 @@ REGISTER_TEST(bufferreadwriterect) memcpy(backing[i], verify[i], size_bytes); // Create the CL buffer. - buffer[i] = clCreateBuffer (context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE, size_bytes, backing[i], &err); + buffer[i] = + clCreateBuffer(context, buffer_flags, size_bytes, backing[i], &err); CL_EXIT_ERROR(err,"clCreateBuffer failed for buffer %u", i); // Make sure buffer is cleaned up appropriately if we encounter an error in the rest of the calls. @@ -496,7 +513,8 @@ REGISTER_TEST(bufferreadwriterect) doffset[0], doffset[1], doffset[2], sregion[0], sregion[1], sregion[2], sregion[0] * sregion[1] * sregion[2]); - if ((err = copy_region(src, soffset, sregion, dst, doffset, dregion))) + if ((err = test_functions.copy(src, soffset, sregion, dst, + doffset, dregion))) return err; break; case 1: @@ -506,7 +524,8 @@ REGISTER_TEST(bufferreadwriterect) doffset[0], doffset[1], doffset[2], sregion[0], sregion[1], sregion[2], sregion[0] * sregion[1] * sregion[2]); - if ((err = read_verify_region(src, soffset, sregion, dst, doffset, dregion))) + if ((err = test_functions.read(src, soffset, sregion, dst, + doffset, dregion))) return err; break; case 2: @@ -516,7 +535,8 @@ REGISTER_TEST(bufferreadwriterect) doffset[0], doffset[1], doffset[2], sregion[0], sregion[1], sregion[2], sregion[0] * sregion[1] * sregion[2]); - if ((err = write_region(src, soffset, sregion, dst, doffset, dregion))) + if ((err = test_functions.write(src, soffset, sregion, dst, + doffset, dregion))) return err; break; } @@ -559,3 +579,15 @@ REGISTER_TEST(bufferreadwriterect) return err; } + +// This is the main test function for the conformance test. +REGISTER_TEST(bufferreadwriterect) +{ + TestFunctions test_functions; + test_functions.copy = copy_region; + test_functions.read = read_verify_region; + test_functions.write = write_region; + return test_bufferreadwriterect_impl( + device, context, queue, num_elements, + CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE, test_functions); +} diff --git a/test_conformance/basic/test_constant.cpp b/test_conformance/basic/test_constant.cpp index b7d7790c..cac547cd 100644 --- a/test_conformance/basic/test_constant.cpp +++ b/test_conformance/basic/test_constant.cpp @@ -22,6 +22,7 @@ #include #include +#include #include #include "testBase.h" @@ -116,7 +117,8 @@ REGISTER_TEST(constant) err = clGetDeviceInfo(device, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(maxSize), &maxSize, 0); test_error(err, "Unable to get max constant buffer size"); - log_info("Device reports CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE %llu bytes.\n", + log_info("Device reports CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE %" PRIu64 + " bytes.\n", maxSize); // Limit test buffer size to 1/4 of CL_DEVICE_GLOBAL_MEM_SIZE diff --git a/test_conformance/basic/test_enqueue_map.cpp b/test_conformance/basic/test_enqueue_map.cpp index c13cebe4..90062bc2 100644 --- a/test_conformance/basic/test_enqueue_map.cpp +++ b/test_conformance/basic/test_enqueue_map.cpp @@ -29,6 +29,9 @@ const cl_mem_flags flag_set[] = { CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR, CL_MEM_USE_HOST_PTR, CL_MEM_COPY_HOST_PTR, + CL_MEM_USE_HOST_PTR | CL_MEM_IMMUTABLE_EXT, + CL_MEM_COPY_HOST_PTR | CL_MEM_IMMUTABLE_EXT, + CL_MEM_COPY_HOST_PTR | CL_MEM_ALLOC_HOST_PTR | CL_MEM_IMMUTABLE_EXT, 0 }; @@ -37,6 +40,9 @@ const char *flag_set_names[] = { "CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR", "CL_MEM_USE_HOST_PTR", "CL_MEM_COPY_HOST_PTR", + "CL_MEM_USE_HOST_PTR | CL_MEM_IMMUTABLE_EXT", + "CL_MEM_COPY_HOST_PTR | CL_MEM_IMMUTABLE_EXT", + "CL_MEM_COPY_HOST_PTR | CL_MEM_ALLOC_HOST_PTR | CL_MEM_IMMUTABLE_EXT", "0" }; // clang-format on @@ -44,7 +50,7 @@ const char *flag_set_names[] = { REGISTER_TEST(enqueue_map_buffer) { int error; - const size_t bufferSize = 256 * 256; + constexpr size_t bufferSize = 256 * 256; MTdataHolder d{ gRandomSeed }; BufferOwningPtr hostPtrData{ malloc(bufferSize) }; BufferOwningPtr referenceData{ malloc(bufferSize) }; @@ -57,18 +63,28 @@ REGISTER_TEST(enqueue_map_buffer) log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]); + if ((flag_set[src_flag_id] & CL_MEM_IMMUTABLE_EXT) + && !is_extension_available(device, + "cl_ext_immutable_memory_objects")) + { + log_info("Device does not support CL_MEM_IMMUTABLE_EXT. " + "Skipping the memory flag.\n"); + continue; + } + generate_random_data(kChar, (unsigned int)bufferSize, d, hostPtrData); memcpy(referenceData, hostPtrData, bufferSize); void *hostPtr = nullptr; cl_mem_flags flags = flag_set[src_flag_id]; + const bool is_immutable_buffer = flags & CL_MEM_IMMUTABLE_EXT; bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR); if (hasHostPtr) hostPtr = hostPtrData; memObject = clCreateBuffer(context, flags, bufferSize, hostPtr, &error); test_error(error, "Unable to create testing buffer"); - if (!hasHostPtr) + if (!hasHostPtr && !is_immutable_buffer) { error = clEnqueueWriteBuffer(queue, memObject, CL_TRUE, 0, bufferSize, @@ -86,7 +102,18 @@ REGISTER_TEST(enqueue_map_buffer) cl_char *mappedRegion = (cl_char *)clEnqueueMapBuffer( queue, memObject, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, offset, length, 0, NULL, NULL, &error); - if (error != CL_SUCCESS) + + // Mapping should fail if the buffer is immutable + if (is_immutable_buffer) + { + test_failure_error_ret( + error, CL_INVALID_OPERATION, + "clEnqueueMapBuffer call was expected to fail " + "with CL_INVALID_OPERATION", + TEST_FAIL); + continue; + } + else if (error != CL_SUCCESS) { print_error(error, "clEnqueueMapBuffer call failed"); log_error("\tOffset: %d Length: %d\n", (int)offset, @@ -122,6 +149,11 @@ REGISTER_TEST(enqueue_map_buffer) finalData, 0, NULL, NULL); test_error(error, "Unable to read results"); + if (is_immutable_buffer && !hasHostPtr) + { + continue; + } + for (size_t q = 0; q < bufferSize; q++) { if (referenceData[q] != finalData[q]) @@ -140,9 +172,10 @@ REGISTER_TEST(enqueue_map_buffer) REGISTER_TEST(enqueue_map_image) { int error; - cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT32 }; - const size_t imageSize = 256; - const size_t imageDataSize = imageSize * imageSize * 4 * sizeof(cl_uint); + constexpr cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT32 }; + constexpr size_t imageSize = 256; + constexpr size_t imageDataSize = + imageSize * imageSize * 4 * sizeof(cl_uint); PASSIVE_REQUIRE_IMAGE_SUPPORT(device) @@ -158,20 +191,30 @@ REGISTER_TEST(enqueue_map_image) log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]); + if ((flag_set[src_flag_id] & CL_MEM_IMMUTABLE_EXT) + && !is_extension_available(device, + "cl_ext_immutable_memory_objects")) + { + log_info("Device does not support CL_MEM_IMMUTABLE_EXT. " + "Skipping the memory flag.\n"); + continue; + } + generate_random_data(kUInt, (unsigned int)(imageSize * imageSize * 4), d, hostPtrData); memcpy(referenceData, hostPtrData, imageDataSize); cl_mem_flags flags = flag_set[src_flag_id]; + bool is_immutable_image = flags & CL_MEM_IMMUTABLE_EXT; bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR); void *hostPtr = nullptr; if (hasHostPtr) hostPtr = hostPtrData; - memObject = create_image_2d(context, CL_MEM_READ_WRITE | flags, &format, - imageSize, imageSize, 0, hostPtr, &error); + memObject = create_image_2d(context, flags, &format, imageSize, + imageSize, 0, hostPtr, &error); test_error(error, "Unable to create testing buffer"); - if (!hasHostPtr) + if (!hasHostPtr && !is_immutable_image) { size_t write_origin[3] = { 0, 0, 0 }, write_region[3] = { imageSize, imageSize, 1 }; @@ -198,7 +241,17 @@ REGISTER_TEST(enqueue_map_image) cl_uint *mappedRegion = (cl_uint *)clEnqueueMapImage( queue, memObject, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, offset, region, &rowPitch, NULL, 0, NULL, NULL, &error); - if (error != CL_SUCCESS) + + if (is_immutable_image) + { + test_failure_error_ret( + error, CL_INVALID_OPERATION, + "clEnqueueMapImage call was expected to fail " + "with CL_INVALID_OPERATION", + TEST_FAIL); + continue; + } + else if (error != CL_SUCCESS) { print_error(error, "clEnqueueMapImage call failed"); log_error("\tOffset: %d,%d Region: %d,%d\n", (int)offset[0], @@ -245,6 +298,11 @@ REGISTER_TEST(enqueue_map_image) finalRegion, 0, 0, finalData, 0, NULL, NULL); test_error(error, "Unable to read results"); + if (is_immutable_image && !hasHostPtr) + { + continue; + } + for (size_t q = 0; q < imageSize * imageSize * 4; q++) { if (referenceData[q] != finalData[q]) diff --git a/test_conformance/basic/test_imagecopy.cpp b/test_conformance/basic/test_imagecopy.cpp index ffcd1b6e..22bdea11 100644 --- a/test_conformance/basic/test_imagecopy.cpp +++ b/test_conformance/basic/test_imagecopy.cpp @@ -1,6 +1,6 @@ // // Copyright (c) 2017 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 @@ -20,213 +20,217 @@ #include #include #include +#include #include "testBase.h" -static unsigned char * -generate_rgba8_image(int w, int h, MTdata d) +static std::unique_ptr generate_rgba8_image(int w, int h, + MTdata d) { - unsigned char *ptr = (unsigned char*)malloc(w * h * 4); - int i; + std::unique_ptr ptr{ new unsigned char[w * h * 4] }; - for (i=0; i generate_rgba16_image(int w, int h, + MTdata d) { - unsigned short *ptr = (unsigned short *)malloc(w * h * 4 * sizeof(unsigned short)); - int i; + std::unique_ptr ptr{ new unsigned short[w * h * 4] }; - for (i=0; i generate_rgbafp_image(int w, int h, MTdata d) { - float *ptr = (float*)malloc(w * h * 4 * sizeof(float)); - int i; + std::unique_ptr ptr{ new float[w * h * 4] }; - for (i=0; i rgba8_inptr, rgba8_outptr; + std::unique_ptr rgba16_inptr, rgba16_outptr; + std::unique_ptr rgbafp_inptr, rgbafp_outptr; + clMemWrapper streams[6]; + int img_width = 512; + int img_height = 512; + int i, err; + MTdataHolder d(gRandomSeed); - PASSIVE_REQUIRE_IMAGE_SUPPORT( device ) + rgba8_inptr = generate_rgba8_image(img_width, img_height, d); + rgba16_inptr = generate_rgba16_image(img_width, img_height, d); + rgbafp_inptr = generate_rgbafp_image(img_width, img_height, d); - d = init_genrand( gRandomSeed ); - rgba8_inptr = (unsigned char *)generate_rgba8_image(img_width, img_height, d); - rgba16_inptr = (unsigned short *)generate_rgba16_image(img_width, img_height, d); - rgbafp_inptr = (float *)generate_rgbafp_image(img_width, img_height, d); - free_mtdata(d); d = NULL; + rgba8_outptr.reset(new unsigned char[4 * img_width * img_height]); + rgba16_outptr.reset(new unsigned short[4 * img_width * img_height]); + rgbafp_outptr.reset(new float[4 * img_width * img_height]); - rgba8_outptr = (unsigned char*)malloc(sizeof(unsigned char) * 4 * img_width * img_height); - rgba16_outptr = (unsigned short*)malloc(sizeof(unsigned short) * 4 * img_width * img_height); - rgbafp_outptr = (float*)malloc(sizeof(float) * 4 * img_width * img_height); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT8; - streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT16; - streams[2] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - streams[3] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_FLOAT; - streams[4] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - streams[5] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - - for (i=0; i<3; i++) + for (size_t index = 0; index < image_formats_count; ++index) { - void *p, *outp; - int x, y, delta_w = img_width/8, delta_h = img_height/16; + void *ptr = nullptr; + if (src_image_flags & CL_MEM_USE_HOST_PTR + || src_image_flags & CL_MEM_COPY_HOST_PTR) + + { + switch (index) + { + case 0: ptr = rgba8_inptr.get(); break; + case 1: ptr = rgba16_inptr.get(); break; + case 2: ptr = rgbafp_inptr.get(); break; + default: break; + } + } + streams[index * 2] = + create_image_2d(context, src_image_flags, &image_formats[index], + img_width, img_height, 0, ptr, &err); + test_error(err, "create_image_2d failed"); + + streams[index * 2 + 1] = + create_image_2d(context, CL_MEM_READ_WRITE, &image_formats[index], + img_width, img_height, 0, nullptr, &err); + test_error(err, "create_image_2d failed"); + } + + for (i = 0; i < 3; i++) + { + void *p, *outp; + int x, y, delta_w = img_width / 8, delta_h = img_height / 16; switch (i) { case 0: - p = (void *)rgba8_inptr; - outp = (void *)rgba8_outptr; - log_info("Testing CL_RGBA CL_UNORM_INT8\n"); + p = rgba8_inptr.get(); + outp = rgba8_outptr.get(); + log_info("Testing CL_RGBA CL_UNORM_INT8\n"); break; case 1: - p = (void *)rgba16_inptr; - outp = (void *)rgba16_outptr; - log_info("Testing CL_RGBA CL_UNORM_INT16\n"); + p = rgba16_inptr.get(); + outp = rgba16_outptr.get(); + log_info("Testing CL_RGBA CL_UNORM_INT16\n"); break; case 2: - p = (void *)rgbafp_inptr; - outp = (void *)rgbafp_outptr; - log_info("Testing CL_RGBA CL_FLOAT\n"); + p = rgbafp_inptr.get(); + outp = rgbafp_outptr.get(); + log_info("Testing CL_RGBA CL_FLOAT\n"); break; } - size_t origin[3] = {0,0,0}, region[3] = {img_width, img_height, 1}; - err = clEnqueueWriteImage(queue, streams[i*2], CL_TRUE, origin, region, 0, 0, p, 0, NULL, NULL); - test_error(err, "create_image_2d failed"); + size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, 1 }; + if (!(src_image_flags & CL_MEM_USE_HOST_PTR + || src_image_flags & CL_MEM_COPY_HOST_PTR)) + { + err = clEnqueueWriteImage(queue, streams[i * 2], CL_TRUE, origin, + region, 0, 0, p, 0, nullptr, nullptr); + test_error(err, "create_image_2d failed"); + } int copy_number = 0; - for (y=0; y #include #include +#include #include "testBase.h" -static unsigned char * +static std::unique_ptr generate_uint8_image(unsigned num_elements, MTdata d) { - unsigned char *ptr = (unsigned char*)malloc(num_elements); - unsigned i; + std::unique_ptr ptr{ new unsigned char[num_elements] }; - for (i=0; i generate_uint16_image(unsigned num_elements, MTdata d) { - unsigned short *ptr = (unsigned short *)malloc(num_elements * sizeof(unsigned short)); - unsigned i; + std::unique_ptr ptr{ new unsigned short[num_elements] }; - for (i=0; i generate_float_image(unsigned num_elements, + MTdata d) { - float *ptr = (float*)malloc(num_elements * sizeof(float)); - unsigned i; + std::unique_ptr ptr{ new float[num_elements] }; - for (i=0; i rgba8_inptr, rgba8_outptr; + std::unique_ptr rgba16_inptr, rgba16_outptr; + std::unique_ptr rgbafp_inptr, rgbafp_outptr; clMemWrapper streams[6]; int img_width = 128; int img_height = 128; int img_depth = 64; int i; - cl_int err; - unsigned num_elems = img_width * img_height * img_depth * 4; - MTdata d; + cl_int err; + unsigned num_elements = img_width * img_height * img_depth * 4; + MTdataHolder d(gRandomSeed); - PASSIVE_REQUIRE_3D_IMAGE_SUPPORT( device ) + rgba8_inptr = generate_uint8_image(num_elements, d); + rgba16_inptr = generate_uint16_image(num_elements, d); + rgbafp_inptr = generate_float_image(num_elements, d); - d = init_genrand( gRandomSeed ); - rgba8_inptr = (unsigned char *)generate_uint8_image(num_elems, d); - rgba16_inptr = (unsigned short *)generate_uint16_image(num_elems, d); - rgbafp_inptr = (float *)generate_float_image(num_elems, d); - free_mtdata(d); d = NULL; + rgba8_outptr.reset(new unsigned char[num_elements]); + rgba16_outptr.reset(new unsigned short[num_elements]); + rgbafp_outptr.reset(new float[num_elements]); - rgba8_outptr = (unsigned char *)malloc(sizeof(unsigned char) * num_elems); - rgba16_outptr = - (unsigned short *)malloc(sizeof(unsigned short) * num_elems); - rgbafp_outptr = (float *)malloc(sizeof(float) * num_elems); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT8; - streams[0] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - streams[1] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT16; - streams[2] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - streams[3] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_FLOAT; - streams[4] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - streams[5] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - - for (i=0; i<3; i++) + for (size_t index = 0; index < image_formats_count; ++index) { - void *p, *outp; - int x, y, z, delta_w = img_width/8, delta_h = img_height/16, delta_d = img_depth/4; + void *ptr = nullptr; + if (src_image_flags & CL_MEM_USE_HOST_PTR + || src_image_flags & CL_MEM_COPY_HOST_PTR) + { + switch (index) + { + case 0: ptr = rgba8_inptr.get(); break; + case 1: ptr = rgba16_inptr.get(); break; + case 2: ptr = rgbafp_inptr.get(); break; + default: break; + } + } + streams[index * 2] = + create_image_3d(context, src_image_flags, &image_formats[index], + img_width, img_height, img_depth, 0, 0, ptr, &err); + test_error(err, "create_image_3d failed"); + + streams[index * 2 + 1] = create_image_3d( + context, CL_MEM_READ_ONLY, &image_formats[index], img_width, + img_height, img_depth, 0, 0, nullptr, &err); + test_error(err, "create_image_3d failed"); + } + + for (i = 0; i < image_formats_count; i++) + { + void *p, *outp; + int x, y, z, delta_w = img_width / 8, delta_h = img_height / 16, + delta_d = img_depth / 4; switch (i) { case 0: - p = (void *)rgba8_inptr; - outp = (void *)rgba8_outptr; + p = rgba8_inptr.get(); + outp = rgba8_outptr.get(); break; case 1: - p = (void *)rgba16_inptr; - outp = (void *)rgba16_outptr; + p = rgba16_inptr.get(); + outp = rgba16_outptr.get(); break; case 2: - p = (void *)rgbafp_inptr; - outp = (void *)rgbafp_outptr; + p = rgbafp_inptr.get(); + outp = rgbafp_outptr.get(); break; } - size_t origin[3]={0,0,0}, region[3]={img_width, img_height, img_depth}; - err = clEnqueueWriteImage(queue, streams[i*2], CL_TRUE, origin, region, 0, 0, p, 0, NULL, NULL); - test_error(err, "clEnqueueWriteImage failed"); - - for (z=0; z #include #include #include @@ -23,16 +24,15 @@ #include "testBase.h" -static unsigned char * -generate_rgba8_image(int w, int h, MTdata d) +static std::unique_ptr generate_rgba8_image(int w, int h, + MTdata d) { - unsigned char *ptr = (unsigned char*)malloc(w * h * 4); - int i; + std::unique_ptr ptr{ new unsigned char[w * h * 4] }; - for (i=0; i generate_rgba16_image(int w, int h, + MTdata d) { - unsigned short *ptr = (unsigned short*)malloc(w * h * 4 * sizeof(unsigned short)); - int i; + std::unique_ptr ptr{ new unsigned short[w * h * 4] }; - for (i=0; i generate_rgbafp_image(int w, int h, MTdata d) { - float *ptr = (float*)malloc(w * h * 4 * sizeof(float)); - int i; + std::unique_ptr ptr{ new float[w * h * 4] }; - for (i=0; i rgba8_inptr, rgba8_outptr; + std::unique_ptr rgba16_inptr, rgba16_outptr; + std::unique_ptr rgbafp_inptr, rgbafp_outptr; clMemWrapper streams[3]; int img_width = 512; int img_height = 512; int num_tries = 200; int i, j, err; - MTdata d; + MTdataHolder d(gRandomSeed); PASSIVE_REQUIRE_IMAGE_SUPPORT( device ) - d = init_genrand( gRandomSeed ); - rgba8_inptr = (unsigned char *)generate_rgba8_image(img_width, img_height, d); - rgba16_inptr = (unsigned short *)generate_rgba16_image(img_width, img_height, d); - rgbafp_inptr = (float *)generate_rgbafp_image(img_width, img_height, d); + rgba8_inptr = generate_rgba8_image(img_width, img_height, d); + rgba16_inptr = generate_rgba16_image(img_width, img_height, d); + rgbafp_inptr = generate_rgbafp_image(img_width, img_height, d); - rgba8_outptr = (unsigned char*)malloc(sizeof(unsigned char) * 4 * img_width * img_height); - rgba16_outptr = (unsigned short*)malloc(sizeof(unsigned short) * 4 * img_width * img_height); - rgbafp_outptr = (float*)malloc(sizeof(float) * 4 * img_width * img_height); + rgba8_outptr.reset(new unsigned char[4 * img_width * img_height]); + rgba16_outptr.reset(new unsigned short[4 * img_width * img_height]); + rgbafp_outptr.reset(new float[4 * img_width * img_height]); - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT8; - streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT16; - streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_FLOAT; - streams[2] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format, - img_width, img_height, 0, NULL, &err); - test_error(err, "create_image_2d failed"); + for (size_t index = 0; index < image_formats_count; ++index) + { + streams[index] = + create_image_2d(context, CL_MEM_READ_WRITE, &image_formats[index], + img_width, img_height, 0, NULL, &err); + test_error(err, "create_image_2d failed"); + } for (i=0; i<3; i++) { void *p; if (i == 0) - p = (void *)rgba8_inptr; + p = rgba8_inptr.get(); else if (i == 1) - p = (void *)rgba16_inptr; + p = rgba16_inptr.get(); else - p = (void *)rgbafp_inptr; + p = rgbafp_inptr.get(); size_t origin[3] = {0,0,0}, region[3] = {img_width, img_height, 1}; err = clEnqueueWriteImage(queue, streams[i], CL_TRUE, origin, region, 0, 0, @@ -250,7 +240,7 @@ REGISTER_TEST(imagereadwrite) } } - for (i=0,j=0; i p_rgba8; + std::unique_ptr p_rgba16; + std::unique_ptr p_rgbaf; int elem_size; - if (j == 3) - j = 0; + if (j == image_formats_count) j = 0; switch (j) { @@ -272,45 +264,57 @@ REGISTER_TEST(imagereadwrite) elem_size = 4; if(packed_update) { - p = generate_rgba8_image(w, h, d); - update_image_from_image(rgba8_inptr, p, x, y, w, h, img_width, elem_size); + p_rgba8 = generate_rgba8_image(w, h, d); + p = p_rgba8.get(); + update_image_from_image(rgba8_inptr.get(), p, x, y, w, h, + img_width, elem_size); } else { - update_rgba8_image(rgba8_inptr, x, y, w, h, img_width, d); - p = (void *)(rgba8_inptr + ((y * img_width + x) * 4)); + update_rgba8_image(rgba8_inptr.get(), x, y, w, h, img_width, + d); + p = static_cast(rgba8_inptr.get() + + ((y * img_width + x) * 4)); } - outp = (void *)rgba8_outptr; + outp = static_cast(rgba8_outptr.get()); break; case 1: //if ((w<=8) || (h<=8)) continue; elem_size = 2*4; if(packed_update) { - p = generate_rgba16_image(w, h, d); - update_image_from_image(rgba16_inptr, p, x, y, w, h, img_width, elem_size); + p_rgba16 = generate_rgba16_image(w, h, d); + p = p_rgba16.get(); + update_image_from_image(rgba16_inptr.get(), p, x, y, w, h, + img_width, elem_size); } else { - update_rgba16_image(rgba16_inptr, x, y, w, h, img_width, d); - p = (void *)(rgba16_inptr + ((y * img_width + x) * 4)); + update_rgba16_image(rgba16_inptr.get(), x, y, w, h, + img_width, d); + p = static_cast(rgba16_inptr.get() + + ((y * img_width + x) * 4)); } - outp = (void *)rgba16_outptr; + outp = static_cast(rgba16_outptr.get()); break; case 2: //if ((w<=8) || (h<=8)) continue; elem_size = 4*4; if(packed_update) { - p = generate_rgbafp_image(w, h, d); - update_image_from_image(rgbafp_inptr, p, x, y, w, h, img_width, elem_size); + p_rgbaf = generate_rgbafp_image(w, h, d); + p = p_rgbaf.get(); + update_image_from_image(rgbafp_inptr.get(), p, x, y, w, h, + img_width, elem_size); } else { - update_rgbafp_image(rgbafp_inptr, x, y, w, h, img_width, d); - p = (void *)(rgbafp_inptr + ((y * img_width + x) * 4)); + update_rgbafp_image(rgbafp_inptr.get(), x, y, w, h, + img_width, d); + p = static_cast(rgbafp_inptr.get() + + ((y * img_width + x) * 4)); } - outp = (void *)rgbafp_outptr; + outp = static_cast(rgbafp_outptr.get()); break; default: log_error("ERROR Invalid j = %d\n", j); @@ -358,8 +362,7 @@ REGISTER_TEST(imagereadwrite) if(packed_update) { - free(p); - p = NULL; + p = nullptr; } memset(outp, 0x7, img_width*img_height*elem_size); @@ -379,7 +382,8 @@ REGISTER_TEST(imagereadwrite) switch (j) { case 0: - err = verify_rgba8_image(rgba8_inptr, rgba8_outptr, img_width, img_height); + err = verify_rgba8_image(rgba8_inptr.get(), rgba8_outptr.get(), + img_width, img_height); if (err) { log_error("x=%d y=%d w=%d h=%d, pitch=%d, try=%d\n", x, y, w, h, (int)input_pitch, (int)i); @@ -387,7 +391,9 @@ REGISTER_TEST(imagereadwrite) } break; case 1: - err = verify_rgba16_image(rgba16_inptr, rgba16_outptr, img_width, img_height); + err = + verify_rgba16_image(rgba16_inptr.get(), rgba16_outptr.get(), + img_width, img_height); if (err) { log_error("x=%d y=%d w=%d h=%d, pitch=%d, try=%d\n", x, y, w, h, (int)input_pitch, (int)i); @@ -395,7 +401,9 @@ REGISTER_TEST(imagereadwrite) } break; case 2: - err = verify_rgbafp_image(rgbafp_inptr, rgbafp_outptr, img_width, img_height); + err = + verify_rgbafp_image(rgbafp_inptr.get(), rgbafp_outptr.get(), + img_width, img_height); if (err) { log_error("x=%d y=%d w=%d h=%d, pitch=%d, try=%d\n", x, y, w, h, (int)input_pitch, (int)i); @@ -407,14 +415,6 @@ REGISTER_TEST(imagereadwrite) if (err) break; } - free_mtdata(d); - free(rgba8_inptr); - free(rgba16_inptr); - free(rgbafp_inptr); - free(rgba8_outptr); - free(rgba16_outptr); - free(rgbafp_outptr); - if (!err) log_info("IMAGE read, write test passed\n"); diff --git a/test_conformance/basic/test_imagereadwrite3d.cpp b/test_conformance/basic/test_imagereadwrite3d.cpp index 1d7351a9..f384c339 100644 --- a/test_conformance/basic/test_imagereadwrite3d.cpp +++ b/test_conformance/basic/test_imagereadwrite3d.cpp @@ -15,6 +15,7 @@ // #include "harness/compat.h" +#include #include #include #include @@ -23,14 +24,13 @@ #include "testBase.h" -static unsigned char * +static std::unique_ptr generate_rgba8_image(int w, int h, int d, MTdata mtData) { - unsigned char *ptr = (unsigned char*)malloc(w * h * d *4); - int i; + std::unique_ptr ptr{ new unsigned char[w * h * d * 4] }; - for (i=0; i generate_rgba16_image(int w, int h, int d, MTdata mtData) { - unsigned short *ptr = (unsigned short*)malloc(w * h * d * 4 * sizeof(unsigned short)); - int i; + std::unique_ptr ptr{ new unsigned short[w * h * d * 4] }; - for (i=0; i generate_rgbafp_image(int w, int h, int d, + MTdata mtData) { - float *ptr = (float*)malloc(w * h * d *4 * sizeof(float)); - int i; + std::unique_ptr ptr{ new float[w * h * d * 4] }; - for (i=0; i rgba8_inptr, rgba8_outptr; + std::unique_ptr rgba16_inptr, rgba16_outptr; + std::unique_ptr rgbafp_inptr, rgbafp_outptr; clMemWrapper streams[3]; int img_width = 64; int img_height = 64; @@ -208,44 +211,41 @@ REGISTER_TEST(imagereadwrite3d) int img_slice = img_width * img_height; int num_tries = 30; int i, j, err; - MTdata mtData; + MTdataHolder mtData(gRandomSeed); PASSIVE_REQUIRE_3D_IMAGE_SUPPORT( device ) - mtData = init_genrand( gRandomSeed ); - rgba8_inptr = (unsigned char *)generate_rgba8_image(img_width, img_height, img_depth, mtData); - rgba16_inptr = (unsigned short *)generate_rgba16_image(img_width, img_height, img_depth, mtData); - rgbafp_inptr = (float *)generate_rgbafp_image(img_width, img_height, img_depth, mtData); + rgba8_inptr = + generate_rgba8_image(img_width, img_height, img_depth, mtData); + rgba16_inptr = + generate_rgba16_image(img_width, img_height, img_depth, mtData); + rgbafp_inptr = + generate_rgbafp_image(img_width, img_height, img_depth, mtData); - rgba8_outptr = (unsigned char*)malloc(sizeof(unsigned char) * 4 * img_width * img_height * img_depth); - rgba16_outptr = (unsigned short*)malloc(sizeof(unsigned short) * 4 * img_width * img_height * img_depth); - rgbafp_outptr = (float*)malloc(sizeof(float) * 4 * img_width * img_height * img_depth); + rgba8_outptr.reset( + new unsigned char[4 * img_width * img_height * img_depth]); + rgba16_outptr.reset( + new unsigned short[4 * img_width * img_height * img_depth]); + rgbafp_outptr.reset(new float[4 * img_width * img_height * img_depth]); - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT8; - streams[0] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); + for (size_t index = 0; index < image_formats_count; ++index) + { + streams[index] = create_image_3d( + context, CL_MEM_READ_ONLY, &image_formats[index], img_width, + img_height, img_depth, 0, 0, nullptr, &err); + test_error(err, "create_image_3d failed"); + } - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_UNORM_INT16; - streams[1] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - - img_format.image_channel_order = CL_RGBA; - img_format.image_channel_data_type = CL_FLOAT; - streams[2] = create_image_3d(context, CL_MEM_READ_ONLY, &img_format, img_width, img_height, img_depth, 0, 0, NULL, &err); - test_error(err, "create_image_3d failed"); - - for (i=0; i<3; i++) + for (i = 0; i < image_formats_count; i++) { void *p; if (i == 0) - p = (void *)rgba8_inptr; + p = rgba8_inptr.get(); else if (i == 1) - p = (void *)rgba16_inptr; + p = rgba16_inptr.get(); else - p = (void *)rgbafp_inptr; + p = rgbafp_inptr.get(); size_t origin[3] = {0,0,0}, region[3] = {img_width, img_height, img_depth}; err = clEnqueueWriteImage(queue, streams[i], CL_TRUE, @@ -255,7 +255,7 @@ REGISTER_TEST(imagereadwrite3d) test_error(err, "clEnqueueWriteImage failed"); } - for (i=0,j=0; i p_rgba8; + std::unique_ptr p_rgba16; + std::unique_ptr p_rgbaf; int elem_size; - if (j == 3) - j = 0; + if (j == image_formats_count) j = 0; // packed: the source image for the write is a whole image . // unpacked: the source image for the write is a subset within a larger image @@ -280,43 +282,64 @@ REGISTER_TEST(imagereadwrite3d) elem_size = 4; if(packed_update) { - p = generate_rgba8_image(w, h, d, mtData); - update_image_from_image(rgba8_inptr, p, x, y, z, w, h, d, img_width, img_height, img_depth, elem_size); + p_rgba8 = generate_rgba8_image(w, h, d, mtData); + p = p_rgba8.get(); + update_image_from_image(rgba8_inptr.get(), p, x, y, z, w, h, + d, img_width, img_height, img_depth, + elem_size); } else { - update_rgba8_image(rgba8_inptr, x, y, z, w, h, d, img_width, img_height, img_depth, mtData); - p = (void *)(rgba8_inptr + ((z * img_slice + y * img_width + x) * 4)); + update_rgba8_image(rgba8_inptr.get(), x, y, z, w, h, d, + img_width, img_height, img_depth, + mtData); + p = static_cast( + rgba8_inptr.get() + + ((z * img_slice + y * img_width + x) * 4)); } - outp = (void *)rgba8_outptr; + outp = static_cast(rgba8_outptr.get()); break; case 1: elem_size = 2*4; if(packed_update) { - p = generate_rgba16_image(w, h, d, mtData); - update_image_from_image(rgba16_inptr, p, x, y, z, w, h, d, img_width, img_height, img_depth, elem_size); + p_rgba16 = generate_rgba16_image(w, h, d, mtData); + p = p_rgba16.get(); + update_image_from_image(rgba16_inptr.get(), p, x, y, z, w, + h, d, img_width, img_height, + img_depth, elem_size); } else { - update_rgba16_image(rgba16_inptr, x, y, z, w, h, d, img_width, img_height, img_depth, mtData); - p = (void *)(rgba16_inptr + ((z * img_slice + y * img_width + x) * 4)); + update_rgba16_image(rgba16_inptr.get(), x, y, z, w, h, d, + img_width, img_height, img_depth, + mtData); + p = static_cast( + rgba16_inptr.get() + + ((z * img_slice + y * img_width + x) * 4)); } - outp = (void *)rgba16_outptr; + outp = static_cast(rgba16_outptr.get()); break; case 2: elem_size = 4*4; if(packed_update) { - p = generate_rgbafp_image(w, h, d, mtData); - update_image_from_image(rgbafp_inptr, p, x, y, z, w, h, d, img_width, img_height, img_depth, elem_size); + p_rgbaf = generate_rgbafp_image(w, h, d, mtData); + p = p_rgbaf.get(); + update_image_from_image(rgbafp_inptr.get(), p, x, y, z, w, + h, d, img_width, img_height, + img_depth, elem_size); } else { - update_rgbafp_image(rgbafp_inptr, x, y, z, w, h, d, img_width, img_height, img_depth, mtData); - p = (void *)(rgbafp_inptr + ((z * img_slice + y * img_width + x) * 4)); + update_rgbafp_image(rgbafp_inptr.get(), x, y, z, w, h, d, + img_width, img_height, img_depth, + mtData); + p = static_cast( + rgbafp_inptr.get() + + ((z * img_slice + y * img_width + x) * 4)); } - outp = (void *)rgbafp_outptr; + outp = static_cast(rgbafp_outptr.get()); break; default: log_error("ERROR Invalid j = %d\n", j); @@ -360,8 +383,7 @@ REGISTER_TEST(imagereadwrite3d) if(packed_update) { - free(p); - p = NULL; + p = nullptr; } memset(outp, 0x7, img_width*img_height*img_depth*elem_size); @@ -375,7 +397,8 @@ REGISTER_TEST(imagereadwrite3d) switch (j) { case 0: - err = verify_rgba8_image(rgba8_inptr, rgba8_outptr, img_width, img_height, img_depth); + err = verify_rgba8_image(rgba8_inptr.get(), rgba8_outptr.get(), + img_width, img_height, img_depth); if (err) { log_error("x=%d y=%d z=%d w=%d h=%d d=%d pitch=%d, slice_pitch=%d, try=%d\n", x, y, z, w, h, d, (int)input_pitch, (int)input_slice_pitch, (int)i); @@ -383,7 +406,9 @@ REGISTER_TEST(imagereadwrite3d) } break; case 1: - err = verify_rgba16_image(rgba16_inptr, rgba16_outptr, img_width, img_height, img_depth); + err = + verify_rgba16_image(rgba16_inptr.get(), rgba16_outptr.get(), + img_width, img_height, img_depth); if (err) { log_error("x=%d y=%d z=%d w=%d h=%d d=%d pitch=%d, slice_pitch=%d, try=%d\n", x, y, z, w, h, d, (int)input_pitch, (int)input_slice_pitch, (int)i); @@ -391,7 +416,9 @@ REGISTER_TEST(imagereadwrite3d) } break; case 2: - err = verify_rgbafp_image(rgbafp_inptr, rgbafp_outptr, img_width, img_height, img_depth); + err = + verify_rgbafp_image(rgbafp_inptr.get(), rgbafp_outptr.get(), + img_width, img_height, img_depth); if (err) { log_error("x=%d y=%d z=%d w=%d h=%d d=%d pitch=%d, slice_pitch=%d, try=%d\n", x, y, z, w, h, d, (int)input_pitch, (int)input_slice_pitch, (int)i); @@ -404,14 +431,6 @@ REGISTER_TEST(imagereadwrite3d) break; } - free_mtdata(mtData); - free(rgba8_inptr); - free(rgba16_inptr); - free(rgbafp_inptr); - free(rgba8_outptr); - free(rgba16_outptr); - free(rgbafp_outptr); - if (!err) log_info("IMAGE read, write test passed\n"); diff --git a/test_conformance/basic/test_intmath.cpp b/test_conformance/basic/test_intmath.cpp index 21c83655..ab05436d 100644 --- a/test_conformance/basic/test_intmath.cpp +++ b/test_conformance/basic/test_intmath.cpp @@ -14,6 +14,7 @@ // limitations under the License. // +#include #include #include #include @@ -182,13 +183,13 @@ static int test_intmath(cl_device_id device, cl_context context, if (r != output[i]) { log_error("\n\nverification failed at index %d\n", i); - log_error("-> inputs: %llu, %llu, %llu\n", - static_cast(inputA[i]), - static_cast(inputB[i]), - static_cast(inputC[i])); - log_error("-> expected %llu, got %llu\n\n", - static_cast(r), - static_cast(output[i])); + log_error("-> inputs: %" PRIu64 "%" PRIu64 "%" PRIu64 "\n", + static_cast(inputA[i]), + static_cast(inputB[i]), + static_cast(inputC[i])); + log_error("-> expected %" PRIu64 "%" PRIu64 "\n\n", + static_cast(r), + static_cast(output[i])); return TEST_FAIL; } } diff --git a/test_conformance/basic/test_kernel_memory_alignment.cpp b/test_conformance/basic/test_kernel_memory_alignment.cpp index f361c621..c8f6526e 100644 --- a/test_conformance/basic/test_kernel_memory_alignment.cpp +++ b/test_conformance/basic/test_kernel_memory_alignment.cpp @@ -17,6 +17,8 @@ #include #endif +#include + #include "harness/conversions.h" #include "harness/typeWrappers.h" #include "harness/errorHelpers.h" @@ -315,9 +317,14 @@ static int test_kernel_memory_alignment(cl_device_id device, cl_context context, for (int i = 0; i < 6; i++) { if ((results_data[i] & alignments[i]) != 0) { total_errors++; - log_error("\tVector size %d failed: 0x%llx is not properly aligned.\n", 1 << i, results_data[i]); + log_error("\tVector size %d failed: 0x%" PRIx64 + " is not properly aligned.\n", + 1 << i, results_data[i]); } else { - if (DEBUG) log_info("\tVector size %d passed: 0x%llx is properly aligned.\n", 1 << i, results_data[i]); + if (DEBUG) + log_info("\tVector size %d passed: 0x%" PRIx64 + " is properly aligned.\n", + 1 << i, results_data[i]); } } } @@ -328,9 +335,14 @@ static int test_kernel_memory_alignment(cl_device_id device, cl_context context, for (int i = 0; i < 6; i++) { if ((results_data_no_long[i] & alignments[i]) != 0) { total_errors++; - log_error("\tVector size %d failed: 0x%llx is not properly aligned.\n", 1 << i, results_data_no_long[i]); + log_error("\tVector size %d failed: 0x%x is not " + "properly aligned.\n", + 1 << i, results_data_no_long[i]); } else { - if (DEBUG) log_info("\tVector size %d passed: 0x%llx is properly aligned.\n", 1 << i, results_data_no_long[i]); + if (DEBUG) + log_info("\tVector size %d passed: 0x%x is " + "properly aligned.\n", + 1 << i, results_data_no_long[i]); } } } @@ -383,9 +395,14 @@ static int test_kernel_memory_alignment(cl_device_id device, cl_context context, for (int i = 0; i < 5; i++) { if ((results_data[i] & alignments[i]) != 0) { total_errors++; - log_error("\tVector size %d failed: 0x%llx is not properly aligned.\n", 1 << i, results_data[i]); + log_error("\tVector size %d failed: 0x%" PRIx64 + " is not properly aligned.\n", + 1 << i, results_data[i]); } else { - if (DEBUG) log_info("\tVector size %d passed: 0x%llx is properly aligned.\n", 1 << i, results_data[i]); + if (DEBUG) + log_info("\tVector size %d passed: 0x%" PRIx64 + " is properly aligned.\n", + 1 << i, results_data[i]); } } } @@ -396,9 +413,14 @@ static int test_kernel_memory_alignment(cl_device_id device, cl_context context, for (int i = 0; i < 5; i++) { if ((results_data_no_long[i] & alignments[i]) != 0) { total_errors++; - log_error("\tVector size %d failed: 0x%llx is not properly aligned.\n", 1 << i, results_data_no_long[i]); + log_error("\tVector size %d failed: 0x%x is not " + "properly aligned.\n", + 1 << i, results_data_no_long[i]); } else { - if (DEBUG) log_info("\tVector size %d passed: 0x%llx is properly aligned.\n", 1 << i, results_data_no_long[i]); + if (DEBUG) + log_info("\tVector size %d passed: 0x%x is " + "properly aligned.\n", + 1 << i, results_data_no_long[i]); } } } @@ -455,9 +477,14 @@ static int test_kernel_memory_alignment(cl_device_id device, cl_context context, for (int i = 0; i < 5; i++) { if ((results_data[i] & alignments[i]) != 0) { total_errors++; - log_error("\tVector size %d failed: 0x%llx is not properly aligned.\n", 1 << i, results_data[i]); + log_error("\tVector size %d failed: 0x%" PRIx64 + " is not properly aligned.\n", + 1 << i, results_data[i]); } else { - if (DEBUG) log_info("\tVector size %d passed: 0x%llx is properly aligned.\n", 1 << i, results_data[i]); + if (DEBUG) + log_info("\tVector size %d passed: 0x%" PRIx64 + " is properly aligned.\n", + 1 << i, results_data[i]); } } } @@ -468,9 +495,14 @@ static int test_kernel_memory_alignment(cl_device_id device, cl_context context, for (int i = 0; i < 5; i++) { if ((results_data_no_long[i] & alignments[i]) != 0) { total_errors++; - log_error("\tVector size %d failed: 0x%llx is not properly aligned.\n", 1 << i, results_data_no_long[i]); + log_error("\tVector size %d failed: 0x%x is not " + "properly aligned.\n", + 1 << i, results_data_no_long[i]); } else { - if (DEBUG) log_info("\tVector size %d passed: 0x%llx is properly aligned.\n", 1 << i, results_data_no_long[i]); + if (DEBUG) + log_info("\tVector size %d passed: 0x%x is " + "properly aligned.\n", + 1 << i, results_data_no_long[i]); } } } diff --git a/test_conformance/basic/test_numeric_constants.cpp b/test_conformance/basic/test_numeric_constants.cpp index d88c8172..719dd1c8 100644 --- a/test_conformance/basic/test_numeric_constants.cpp +++ b/test_conformance/basic/test_numeric_constants.cpp @@ -15,6 +15,8 @@ // #include "testBase.h" +#include + #define TEST_VALUE_POSITIVE( string_name, name, value ) \ { \ if (name < value) { \ @@ -528,7 +530,14 @@ const char *kernel_constant_double_limits[] = { }; #define TEST_FLOAT_ASSERTION( a, msg, f ) if( !( a ) ) { log_error( "ERROR: Float constant failed requirement: %s (bitwise value is 0x%8.8x)\n", msg, *( (uint32_t *)&f ) ); return -1; } -#define TEST_DOUBLE_ASSERTION( a, msg, f ) if( !( a ) ) { log_error( "ERROR: Double constant failed requirement: %s (bitwise value is 0x%16.16llx)\n", msg, *( (uint64_t *)&f ) ); return -1; } +#define TEST_DOUBLE_ASSERTION(a, msg, f) \ + if (!(a)) \ + { \ + log_error("ERROR: Double constant failed requirement: %s (bitwise " \ + "value is 0x%16.16" PRIx64 ")\n", \ + msg, *((uint64_t *)&f)); \ + return -1; \ + } REGISTER_TEST(kernel_limit_constants) { diff --git a/test_conformance/basic/test_sizeof.cpp b/test_conformance/basic/test_sizeof.cpp index 8827727e..ac0a84f9 100644 --- a/test_conformance/basic/test_sizeof.cpp +++ b/test_conformance/basic/test_sizeof.cpp @@ -21,6 +21,8 @@ #include #include +#include + #include "testBase.h" cl_int get_type_size( cl_context context, cl_command_queue queue, const char *type, cl_ulong *size, cl_device_id device ) @@ -161,12 +163,16 @@ REGISTER_TEST(sizeof) return err; if( test != scalar_table[i].size ) { - log_error( "\nFAILED: Type %s has size %lld, but expected size %lld!\n", scalar_table[i].name, test, scalar_table[i].size ); + log_error("\nFAILED: Type %s has size %" PRId64 + ", but expected size %" PRId64 "!\n", + scalar_table[i].name, test, scalar_table[i].size); return -1; } if( test != scalar_table[i].cl_size ) { - log_error( "\nFAILED: Type %s has size %lld, but cl_ size is %lld!\n", scalar_table[i].name, test, scalar_table[i].cl_size ); + log_error("\nFAILED: Type %s has size %" PRId64 + ", but cl_ size is %" PRId64 "!\n", + scalar_table[i].name, test, scalar_table[i].cl_size); return -2; } log_info( "%16s", scalar_table[i].name ); @@ -196,16 +202,16 @@ REGISTER_TEST(sizeof) return err; if( test != j * vector_table[i].size ) { - log_error( - "\nFAILED: Type %s has size %lld, but expected size %zu!\n", - name, test, j * vector_table[i].size); + log_error("\nFAILED: Type %s has size %" PRId64 + ", but expected size %" PRIu64 "!\n", + name, test, j * vector_table[i].size); return -1; } if( test != j * vector_table[i].cl_size ) { - log_error( - "\nFAILED: Type %s has size %lld, but cl_ size is %zu!\n", - name, test, j * vector_table[i].cl_size); + log_error("\nFAILED: Type %s has size %" PRId64 + ", but cl_ size is %" PRIu64 "!\n", + name, test, j * vector_table[i].cl_size); return -2; } log_info( "%16s", name ); @@ -222,7 +228,9 @@ REGISTER_TEST(sizeof) return err; if( test != ptr_size ) { - log_error( "\nFAILED: Type %s has size %lld, but expected size %u!\n", ptr_table[i], test, ptr_size ); + log_error("\nFAILED: Type %s has size %" PRId64 + ", but expected size %u!\n", + ptr_table[i], test, ptr_size); return -1; } log_info( "%16s", ptr_table[i] ); @@ -235,12 +243,16 @@ REGISTER_TEST(sizeof) return err; if( test < ptr_size ) { - log_error( "\nFAILED: intptr_t has size %lld, but must be at least %u!\n", test, ptr_size ); + log_error("\nFAILED: intptr_t has size %" PRId64 + ", but must be at least %u!\n", + test, ptr_size); return -1; } if( ! IsPowerOfTwo( test ) ) { - log_error( "\nFAILED: sizeof(intptr_t) is %lld, but must be a power of two!\n", test ); + log_error("\nFAILED: sizeof(intptr_t) is %" PRId64 + ", but must be a power of two!\n", + test); return -2; } log_info( "%16s", "intptr_t" ); @@ -252,12 +264,16 @@ REGISTER_TEST(sizeof) return err; if( test < ptr_size ) { - log_error( "\nFAILED: uintptr_t has size %lld, but must be at least %u!\n", test, ptr_size ); + log_error("\nFAILED: uintptr_t has size %" PRId64 + ", but must be at least %u!\n", + test, ptr_size); return -1; } if( ! IsPowerOfTwo( test ) ) { - log_error( "\nFAILED: sizeof(uintptr_t) is %lld, but must be a power of two!\n", test ); + log_error("\nFAILED: sizeof(uintptr_t) is %" PRId64 + ", but must be a power of two!\n", + test); return -2; } log_info( "%16s\n", "uintptr_t" ); @@ -293,7 +309,9 @@ REGISTER_TEST(sizeof) return err; if( ! IsPowerOfTwo( test ) ) { - log_error( "\nFAILED: Type %s has size %lld, which is not a power of two (section 6.1.5)!\n", other_types[i], test ); + log_error("\nFAILED: Type %s has size %" PRId64 + ", which is not a power of two (section 6.1.5)!\n", + other_types[i], test); return -1; } log_info( "%16s", other_types[i] ); @@ -311,7 +329,8 @@ REGISTER_TEST(sizeof) return err; if( test != 8 ) { - log_error( "\nFAILED: double has size %lld, but must be 8!\n", test ); + log_error("\nFAILED: double has size %" PRId64 ", but must be 8!\n", + test); return -1; } log_info( "%16s", "double" ); @@ -328,7 +347,8 @@ REGISTER_TEST(sizeof) return err; if( test != 8*j ) { - log_error("\nFAILED: %s has size %lld, but must be %zu!\n", + log_error("\nFAILED: %s has size %" PRId64 + ", but must be %zu!\n", name, test, 8 * j); return -1; } @@ -347,7 +367,8 @@ REGISTER_TEST(sizeof) return err; if( test != 2 ) { - log_error( "\nFAILED: half has size %lld, but must be 2!\n", test ); + log_error("\nFAILED: half has size %" PRId64 ", but must be 2!\n", + test); return -1; } log_info( "%16s", "half" ); @@ -364,7 +385,8 @@ REGISTER_TEST(sizeof) return err; if( test != 2*j ) { - log_error("\nFAILED: %s has size %lld, but must be %zu!\n", + log_error("\nFAILED: %s has size %" PRId64 + ", but must be %zu!\n", name, test, 2 * j); return -1; } diff --git a/test_conformance/basic/test_vector_swizzle.cpp b/test_conformance/basic/test_vector_swizzle.cpp index ad3a3959..a2db9b9d 100644 --- a/test_conformance/basic/test_vector_swizzle.cpp +++ b/test_conformance/basic/test_vector_swizzle.cpp @@ -605,7 +605,7 @@ template static int test_vectype(const char* type_name, cl_device_id device, cl_context context, cl_command_queue queue) { - log_info(" testing type %s%d\n", type_name, N); + log_info(" testing type %s%zu\n", type_name, N); cl_int error = CL_SUCCESS; int result = TEST_PASS; diff --git a/test_conformance/buffers/test_buffer_copy.cpp b/test_conformance/buffers/test_buffer_copy.cpp index 093987f8..81dbd5cf 100644 --- a/test_conformance/buffers/test_buffer_copy.cpp +++ b/test_conformance/buffers/test_buffer_copy.cpp @@ -15,6 +15,7 @@ // #include "harness/compat.h" +#include #include #include #include @@ -36,210 +37,246 @@ static int verify_copy_buffer(int *inptr, int *outptr, int n) return 0; } +using alignedOwningPtr = std::unique_ptr; static int test_copy( cl_command_queue queue, cl_context context, int num_elements, MTdata d ) { - cl_mem buffers[2]; - cl_int *int_input_ptr, *int_output_ptr; - cl_int err; - int i; - int src_flag_id, dst_flag_id; - int errors = 0; + clMemWrapper buffers[2]; + cl_int err = CL_SUCCESS; size_t min_alignment = get_min_alignment(context); - int_input_ptr = (cl_int*) align_malloc(sizeof(cl_int) * num_elements, min_alignment); - int_output_ptr = (cl_int*)align_malloc(sizeof(cl_int) * num_elements, min_alignment); + alignedOwningPtr invalid_ptr{ + (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment), + align_free + }; + if (!invalid_ptr) + { + log_error(" unable to allocate %zu bytes of memory\n", + sizeof(cl_int) * num_elements); + return TEST_FAIL; + } + alignedOwningPtr out_ptr{ (cl_int *)align_malloc( + sizeof(cl_int) * num_elements, min_alignment), + align_free }; + if (!out_ptr) + { + log_error(" unable to allocate %zu bytes of memory\n", + sizeof(cl_int) * num_elements); + return TEST_FAIL; + } + alignedOwningPtr reference_ptr{ + (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment), + align_free + }; + if (!reference_ptr) + { + log_error(" unable to allocate %zu bytes of memory\n", + sizeof(cl_int) * num_elements); + return TEST_FAIL; + } - for (src_flag_id=0; src_flag_id < NUM_FLAGS; src_flag_id++) { - for (dst_flag_id=0; dst_flag_id < NUM_FLAGS; dst_flag_id++) { + for (int src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++) + { + for (int dst_flag_id = 0; dst_flag_id < NUM_FLAGS; dst_flag_id++) + { log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]); - for (i=0; i(0xdeaddead); + out_ptr[i] = static_cast(0xdeadbeef); + reference_ptr[i] = (int)genrand_int32(d); } + if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) - buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, int_input_ptr, &err); + buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], + sizeof(cl_int) * num_elements, + reference_ptr.get(), &err); else - buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, NULL, &err); + buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], + sizeof(cl_int) * num_elements, + nullptr, &err); if ( err != CL_SUCCESS ){ - print_error(err, " clCreateBuffer failed\n" ); - align_free( (void *)int_input_ptr ); - align_free( (void *)int_output_ptr ); - return -1; + print_error(err, "clCreateBuffer failed\n"); + return TEST_FAIL; } if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR)) - buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, int_output_ptr, &err); + buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], + sizeof(cl_int) * num_elements, + invalid_ptr.get(), &err); else - buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, NULL, &err); + buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], + sizeof(cl_int) * num_elements, + nullptr, &err); if ( err != CL_SUCCESS ){ - print_error(err, " clCreateBuffer failed\n" ); - clReleaseMemObject( buffers[0] ); - align_free( (void *)int_input_ptr ); - align_free( (void *)int_output_ptr ); - return -1; + print_error(err, "clCreateBuffer failed\n"); + return TEST_FAIL; } if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) { - err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, sizeof(cl_int)*num_elements, (void *)int_input_ptr, 0, NULL, NULL); + err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, + sizeof(cl_int) * num_elements, + reference_ptr.get(), 0, nullptr, + nullptr); if ( err != CL_SUCCESS ){ - print_error( err, "clEnqueueWriteBuffer failed" ); - clReleaseMemObject( buffers[0] ); - clReleaseMemObject( buffers[1] ); - align_free( (void *)int_output_ptr ); - align_free( (void *)int_input_ptr ); - return -1; + print_error(err, "clEnqueueWriteBuffer failed\n"); + return TEST_FAIL; } } - err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], 0, 0, sizeof(cl_int)*num_elements, 0, NULL, NULL); + err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], 0, 0, + sizeof(cl_int) * num_elements, 0, nullptr, + nullptr); if ( err != CL_SUCCESS ){ - print_error( err, "clCopyArray failed" ); - clReleaseMemObject( buffers[0] ); - clReleaseMemObject( buffers[1] ); - align_free( (void *)int_output_ptr ); - align_free( (void *)int_input_ptr ); - return -1; + print_error(err, "clCopyArray failed\n"); + return TEST_FAIL; } - err = clEnqueueReadBuffer( queue, buffers[1], true, 0, sizeof(int)*num_elements, (void *)int_output_ptr, 0, NULL, NULL ); + err = clEnqueueReadBuffer(queue, buffers[1], true, 0, + sizeof(int) * num_elements, out_ptr.get(), + 0, nullptr, nullptr); if ( err != CL_SUCCESS ){ - print_error( err, "clEnqueueReadBuffer failed" ); - clReleaseMemObject( buffers[0] ); - clReleaseMemObject( buffers[1] ); - align_free( (void *)int_output_ptr ); - align_free( (void *)int_input_ptr ); - return -1; + print_error(err, "clEnqueueReadBuffer failed\n"); + return TEST_FAIL; } - if ( verify_copy_buffer(int_input_ptr, int_output_ptr, num_elements) ){ + if (verify_copy_buffer(reference_ptr.get(), out_ptr.get(), + num_elements)) + { log_error( " test failed\n" ); - errors++; + return TEST_FAIL; } else{ log_info( " test passed\n" ); } - // cleanup - clReleaseMemObject( buffers[0] ); - clReleaseMemObject( buffers[1] ); } // dst flags - } // src flags - // cleanup - align_free( (void *)int_output_ptr ); - align_free( (void *)int_input_ptr ); + } // src flags - return errors; + return TEST_PASS; } // end test_copy() static int testPartialCopy( cl_command_queue queue, cl_context context, int num_elements, cl_uint srcStart, cl_uint dstStart, int size, MTdata d ) { - cl_mem buffers[2]; - int *inptr, *outptr; - cl_int err; - int i; - int src_flag_id, dst_flag_id; - int errors = 0; + clMemWrapper buffers[2]; + cl_int err = CL_SUCCESS; size_t min_alignment = get_min_alignment(context); - inptr = (int *)align_malloc( sizeof(int) * num_elements, min_alignment); - if ( ! inptr ){ - log_error( " unable to allocate %d bytes of memory\n", (int)sizeof(int) * num_elements ); - return -1; + alignedOwningPtr invalid_ptr{ + (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment), + align_free + }; + if (!invalid_ptr) + { + log_error(" unable to allocate %zu bytes of memory\n", + sizeof(cl_int) * num_elements); + return TEST_FAIL; } - outptr = (int *)align_malloc( sizeof(int) * num_elements, min_alignment); - if ( ! outptr ){ - log_error( " unable to allocate %d bytes of memory\n", (int)sizeof(int) * num_elements ); - align_free( (void *)inptr ); - return -1; + alignedOwningPtr out_ptr{ (cl_int *)align_malloc( + sizeof(cl_int) * num_elements, min_alignment), + align_free }; + if (!out_ptr) + { + log_error(" unable to allocate %zu bytes of memory\n", + sizeof(cl_int) * num_elements); + return TEST_FAIL; + } + alignedOwningPtr reference_ptr{ + (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment), + align_free + }; + if (!reference_ptr) + { + log_error(" unable to allocate %zu bytes of memory\n", + sizeof(cl_int) * num_elements); + return TEST_FAIL; } - for (src_flag_id=0; src_flag_id < NUM_FLAGS; src_flag_id++) { - for (dst_flag_id=0; dst_flag_id < NUM_FLAGS; dst_flag_id++) { + for (int src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++) + { + for (int dst_flag_id = 0; dst_flag_id < NUM_FLAGS; dst_flag_id++) + { log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]); - for (i=0; i(0xdeaddead); + out_ptr[i] = static_cast(0xdeadbeef); + reference_ptr[i] = (int)genrand_int32(d); } if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) - buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, inptr, &err); + buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], + sizeof(cl_int) * num_elements, + reference_ptr.get(), &err); else - buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, NULL, &err); + buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], + sizeof(cl_int) * num_elements, + nullptr, &err); if ( err != CL_SUCCESS ){ - print_error(err, " clCreateBuffer failed\n" ) - align_free( (void *)outptr ); - align_free( (void *)inptr ); - return -1; + print_error(err, "clCreateBuffer failed\n"); + return TEST_FAIL; } if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR)) - buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, outptr, &err); + buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], + sizeof(cl_int) * num_elements, + invalid_ptr.get(), &err); else - buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, NULL, &err); + buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], + sizeof(cl_int) * num_elements, + nullptr, &err); if ( err != CL_SUCCESS ){ - print_error(err, " clCreateBuffer failed\n" ); - clReleaseMemObject( buffers[0] ); - align_free( (void *)outptr ); - align_free( (void *)inptr ); - return -1; + print_error(err, "clCreateBuffer failed\n"); + return TEST_FAIL; } if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)){ - err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, sizeof(cl_int)*num_elements, (void *)inptr, 0, NULL, NULL); + err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, + sizeof(cl_int) * num_elements, + reference_ptr.get(), 0, nullptr, + nullptr); if ( err != CL_SUCCESS ){ - print_error( err, "clEnqueueWriteBuffer failed" ); - clReleaseMemObject( buffers[1] ); - clReleaseMemObject( buffers[0] ); - align_free( (void *)outptr ); - align_free( (void *)inptr ); - return -1; + print_error(err, "clEnqueueWriteBuffer failed\n"); + return TEST_FAIL; } } - err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], srcStart*sizeof(cl_int), dstStart*sizeof(cl_int), sizeof(cl_int)*size, 0, NULL, NULL); + err = clEnqueueCopyBuffer( + queue, buffers[0], buffers[1], srcStart * sizeof(cl_int), + dstStart * sizeof(cl_int), sizeof(cl_int) * size, 0, nullptr, + nullptr); if ( err != CL_SUCCESS){ - print_error( err, "clEnqueueCopyBuffer failed" ); - clReleaseMemObject( buffers[1] ); - clReleaseMemObject( buffers[0] ); - align_free( (void *)outptr ); - align_free( (void *)inptr ); - return -1; + print_error(err, "clEnqueueCopyBuffer failed\n"); + return TEST_FAIL; } - err = clEnqueueReadBuffer( queue, buffers[1], true, 0, sizeof(int)*num_elements, (void *)outptr, 0, NULL, NULL ); + err = clEnqueueReadBuffer(queue, buffers[1], true, 0, + sizeof(int) * num_elements, out_ptr.get(), + 0, nullptr, nullptr); if ( err != CL_SUCCESS){ - print_error( err, "clEnqueueReadBuffer failed" ); - clReleaseMemObject( buffers[1] ); - clReleaseMemObject( buffers[0] ); - align_free( (void *)outptr ); - align_free( (void *)inptr ); - return -1; + print_error(err, "clEnqueueReadBuffer failed\n"); + return TEST_FAIL; } - if ( verify_copy_buffer(inptr + srcStart, outptr + dstStart, size) ){ + if (verify_copy_buffer(reference_ptr.get() + srcStart, + out_ptr.get() + dstStart, size)) + { log_error("buffer_COPY test failed\n"); - errors++; + return TEST_FAIL; } else{ log_info("buffer_COPY test passed\n"); } - // cleanup - clReleaseMemObject( buffers[1] ); - clReleaseMemObject( buffers[0] ); } // dst mem flags } // src mem flags - // cleanup - align_free( (void *)outptr ); - align_free( (void *)inptr ); - return errors; + return TEST_PASS; } // end testPartialCopy() @@ -252,15 +289,19 @@ REGISTER_TEST(buffer_copy) // test the preset size log_info( "set size: %d: ", num_elements ); - if (test_copy( queue, context, num_elements, d )) + if (test_copy(queue, context, num_elements, d) != TEST_PASS) + { err++; + } // now test random sizes for ( i = 0; i < 8; i++ ){ size = (int)get_random_float(2.f,131072.f, d); log_info( "random size: %d: ", size ); - if (test_copy( queue, context, size, d )) + if (test_copy(queue, context, size, d) != TEST_PASS) + { err++; + } } free_mtdata(d); @@ -283,8 +324,12 @@ REGISTER_TEST(buffer_partial_copy) size = (int)get_random_float( 8.f, (float)(num_elements - srcStart), d ); dstStart = (cl_uint)get_random_float( 0.f, (float)(num_elements - size), d ); log_info( "random partial copy from %d to %d, size: %d: ", (int)srcStart, (int)dstStart, size ); - if (testPartialCopy( queue, context, num_elements, srcStart, dstStart, size, d )) + if (testPartialCopy(queue, context, num_elements, srcStart, dstStart, + size, d) + != TEST_PASS) + { err++; + } } free_mtdata(d); diff --git a/test_conformance/c11_atomics/common.cpp b/test_conformance/c11_atomics/common.cpp index 668d7b50..414d877b 100644 --- a/test_conformance/c11_atomics/common.cpp +++ b/test_conformance/c11_atomics/common.cpp @@ -58,30 +58,28 @@ cl_uint AtomicTypeInfo::Size(cl_device_id device) { switch(_type) { - case TYPE_ATOMIC_INT: - case TYPE_ATOMIC_UINT: - case TYPE_ATOMIC_FLOAT: - case TYPE_ATOMIC_FLAG: - return sizeof(cl_int); - case TYPE_ATOMIC_LONG: - case TYPE_ATOMIC_ULONG: - case TYPE_ATOMIC_DOUBLE: - return sizeof(cl_long); - case TYPE_ATOMIC_INTPTR_T: - case TYPE_ATOMIC_UINTPTR_T: - case TYPE_ATOMIC_SIZE_T: - case TYPE_ATOMIC_PTRDIFF_T: - { - int error; - cl_uint addressBits = 0; + case TYPE_ATOMIC_HALF: return sizeof(cl_half); + case TYPE_ATOMIC_INT: + case TYPE_ATOMIC_UINT: + case TYPE_ATOMIC_FLOAT: + case TYPE_ATOMIC_FLAG: return sizeof(cl_int); + case TYPE_ATOMIC_LONG: + case TYPE_ATOMIC_ULONG: + case TYPE_ATOMIC_DOUBLE: return sizeof(cl_long); + case TYPE_ATOMIC_INTPTR_T: + case TYPE_ATOMIC_UINTPTR_T: + case TYPE_ATOMIC_SIZE_T: + case TYPE_ATOMIC_PTRDIFF_T: { + int error; + cl_uint addressBits = 0; - error = clGetDeviceInfo(device, CL_DEVICE_ADDRESS_BITS, sizeof(addressBits), &addressBits, 0); - test_error_ret(error, "clGetDeviceInfo", 0); + error = clGetDeviceInfo(device, CL_DEVICE_ADDRESS_BITS, + sizeof(addressBits), &addressBits, 0); + test_error_ret(error, "clGetDeviceInfo", 0); - return addressBits/8; - } - default: - return 0; + return addressBits / 8; + } + default: return 0; } } @@ -93,6 +91,7 @@ const char *AtomicTypeInfo::AtomicTypeName() return "atomic_int"; case TYPE_ATOMIC_UINT: return "atomic_uint"; + case TYPE_ATOMIC_HALF: return "atomic_half"; case TYPE_ATOMIC_FLOAT: return "atomic_float"; case TYPE_ATOMIC_FLAG: @@ -124,6 +123,7 @@ const char *AtomicTypeInfo::RegularTypeName() return "int"; case TYPE_ATOMIC_UINT: return "uint"; + case TYPE_ATOMIC_HALF: return "half"; case TYPE_ATOMIC_FLOAT: return "float"; case TYPE_ATOMIC_FLAG: @@ -163,29 +163,30 @@ int AtomicTypeInfo::IsSupported(cl_device_id device) { switch(_type) { - case TYPE_ATOMIC_INT: - case TYPE_ATOMIC_UINT: - case TYPE_ATOMIC_FLOAT: - case TYPE_ATOMIC_FLAG: - return 1; - case TYPE_ATOMIC_LONG: - case TYPE_ATOMIC_ULONG: - return is_extension_available(device, "cl_khr_int64_base_atomics") && - is_extension_available(device, "cl_khr_int64_extended_atomics"); - case TYPE_ATOMIC_DOUBLE: - return is_extension_available(device, "cl_khr_int64_base_atomics") && - is_extension_available(device, "cl_khr_int64_extended_atomics") && - is_extension_available(device, "cl_khr_fp64"); - case TYPE_ATOMIC_INTPTR_T: - case TYPE_ATOMIC_UINTPTR_T: - case TYPE_ATOMIC_SIZE_T: - case TYPE_ATOMIC_PTRDIFF_T: - if(Size(device) == 4) - return 1; - return is_extension_available(device, "cl_khr_int64_base_atomics") && - is_extension_available(device, "cl_khr_int64_extended_atomics"); - default: - return 0; + case TYPE_ATOMIC_HALF: + return is_extension_available(device, "cl_khr_fp16"); + case TYPE_ATOMIC_INT: + case TYPE_ATOMIC_UINT: + case TYPE_ATOMIC_FLOAT: + case TYPE_ATOMIC_FLAG: return 1; + case TYPE_ATOMIC_LONG: + case TYPE_ATOMIC_ULONG: + return is_extension_available(device, "cl_khr_int64_base_atomics") + && is_extension_available(device, + "cl_khr_int64_extended_atomics"); + case TYPE_ATOMIC_DOUBLE: + return is_extension_available(device, "cl_khr_int64_base_atomics") + && is_extension_available(device, "cl_khr_int64_extended_atomics") + && is_extension_available(device, "cl_khr_fp64"); + case TYPE_ATOMIC_INTPTR_T: + case TYPE_ATOMIC_UINTPTR_T: + case TYPE_ATOMIC_SIZE_T: + case TYPE_ATOMIC_PTRDIFF_T: + if (Size(device) == 4) return 1; + return is_extension_available(device, "cl_khr_int64_base_atomics") + && is_extension_available(device, + "cl_khr_int64_extended_atomics"); + default: return 0; } } diff --git a/test_conformance/c11_atomics/common.h b/test_conformance/c11_atomics/common.h index 76d1fe27..3cab98ce 100644 --- a/test_conformance/c11_atomics/common.h +++ b/test_conformance/c11_atomics/common.h @@ -22,6 +22,8 @@ #include "host_atomics.h" +#include "CL/cl_half.h" + #include #include @@ -38,6 +40,7 @@ enum TExplicitAtomicType TYPE_ATOMIC_UINT, TYPE_ATOMIC_LONG, TYPE_ATOMIC_ULONG, + TYPE_ATOMIC_HALF, TYPE_ATOMIC_FLOAT, TYPE_ATOMIC_DOUBLE, TYPE_ATOMIC_INTPTR_T, @@ -71,6 +74,9 @@ extern int gMaxDeviceThreads; // maximum number of threads executed on OCL device extern cl_device_atomic_capabilities gAtomicMemCap, gAtomicFenceCap; // atomic memory and fence capabilities for this device +extern cl_half_rounding_mode gHalfRoundingMode; +extern bool gFloatAtomicsSupported; +extern cl_device_fp_atomic_capabilities_ext gHalfAtomicCaps; extern const char * get_memory_order_type_name(TExplicitMemoryOrderType orderType); @@ -240,13 +246,13 @@ public: int error = 0; if (_maxDeviceThreads > 0 && !UseSVM()) { - LocalMemory(true); + SetLocalMemory(true); EXECUTE_TEST( error, ExecuteForEachDeclarationType(deviceID, context, queue)); } if (_maxDeviceThreads + MaxHostThreads() > 0) { - LocalMemory(false); + SetLocalMemory(false); EXECUTE_TEST( error, ExecuteForEachDeclarationType(deviceID, context, queue)); } @@ -401,7 +407,7 @@ public: bool UseSVM() { return _useSVM; } void StartValue(HostDataType startValue) { _startValue = startValue; } HostDataType StartValue() { return _startValue; } - void LocalMemory(bool local) { _localMemory = local; } + void SetLocalMemory(bool local) { _localMemory = local; } bool LocalMemory() { return _localMemory; } void DeclaredInProgram(bool declaredInProgram) { @@ -781,6 +787,8 @@ CBasicTest::PragmaHeader(cl_device_id deviceID) } if (_dataType == TYPE_ATOMIC_DOUBLE) pragma += "#pragma OPENCL EXTENSION cl_khr_fp64 : enable\n"; + if (_dataType == TYPE_ATOMIC_HALF) + pragma += "#pragma OPENCL EXTENSION cl_khr_fp16 : enable\n"; return pragma; } @@ -875,7 +883,14 @@ CBasicTest::ProgramHeader(cl_uint maxNumDestItems) header += std::string("__global volatile ") + aTypeName + " destMemory[" + ss.str() + "] = {\n"; ss.str(""); - ss << _startValue; + + if (CBasicTest::DataType()._type + != TYPE_ATOMIC_HALF) + ss << _startValue; + else + ss << static_cast( + cl_half_to_float(static_cast(_startValue))); + for (cl_uint i = 0; i < maxNumDestItems; i++) { if (aTypeName == "atomic_flag") diff --git a/test_conformance/c11_atomics/host_atomics.h b/test_conformance/c11_atomics/host_atomics.h index efa36ad3..e5b1d328 100644 --- a/test_conformance/c11_atomics/host_atomics.h +++ b/test_conformance/c11_atomics/host_atomics.h @@ -41,6 +41,7 @@ enum TExplicitMemoryOrderType #define HOST_ATOMIC_UINT unsigned long #define HOST_ATOMIC_LONG unsigned long long #define HOST_ATOMIC_ULONG unsigned long long +#define HOST_ATOMIC_HALF unsigned short #define HOST_ATOMIC_FLOAT float #define HOST_ATOMIC_DOUBLE double #else @@ -48,6 +49,7 @@ enum TExplicitMemoryOrderType #define HOST_ATOMIC_UINT cl_uint #define HOST_ATOMIC_LONG cl_long #define HOST_ATOMIC_ULONG cl_ulong +#define HOST_ATOMIC_HALF cl_half #define HOST_ATOMIC_FLOAT cl_float #define HOST_ATOMIC_DOUBLE cl_double #endif @@ -69,6 +71,7 @@ enum TExplicitMemoryOrderType #define HOST_UINT cl_uint #define HOST_LONG cl_long #define HOST_ULONG cl_ulong +#define HOST_HALF cl_half #define HOST_FLOAT cl_float #define HOST_DOUBLE cl_double @@ -120,9 +123,12 @@ CorrespondingType host_atomic_exchange(volatile AtomicType *a, CorrespondingType TExplicitMemoryOrderType order) { #if defined( _MSC_VER ) || (defined( __INTEL_COMPILER ) && defined(WIN32)) - return InterlockedExchange(a, c); + if (sizeof(CorrespondingType) == 2) + return InterlockedExchange16(reinterpret_cast(a), c); + else + return InterlockedExchange(reinterpret_cast(a), c); #elif defined(__GNUC__) - return __sync_lock_test_and_set(a, c); + return __sync_lock_test_and_set(a, c); #else log_info("Host function not implemented: atomic_exchange\n"); return 0; @@ -158,7 +164,10 @@ CorrespondingType host_atomic_load(volatile AtomicType *a, TExplicitMemoryOrderType order) { #if defined( _MSC_VER ) || (defined( __INTEL_COMPILER ) && defined(WIN32)) - return InterlockedExchangeAdd(a, 0); + if (sizeof(CorrespondingType) == 2) + auto prev = InterlockedOr16(reinterpret_cast(a), 0); + else + return InterlockedExchangeAdd(reinterpret_cast(a), 0); #elif defined(__GNUC__) return __sync_add_and_fetch(a, 0); #else diff --git a/test_conformance/c11_atomics/main.cpp b/test_conformance/c11_atomics/main.cpp index 4b37f745..40972b26 100644 --- a/test_conformance/c11_atomics/main.cpp +++ b/test_conformance/c11_atomics/main.cpp @@ -1,6 +1,6 @@ // -// Copyright (c) 2017 The Khronos Group Inc. -// +// 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 @@ -14,8 +14,11 @@ // limitations under the License. // #include "harness/testHarness.h" +#include "harness/deviceInfo.h" +#include "harness/kernelHelpers.h" #include #include +#include "CL/cl_half.h" bool gHost = false; // flag for testing native host threads (test verification) bool gOldAPI = false; // flag for testing with old API (OpenCL 1.2) - test verification @@ -28,6 +31,9 @@ int gInternalIterations = 10000; // internal test iterations for atomic operatio int gMaxDeviceThreads = 1024; // maximum number of threads executed on OCL device cl_device_atomic_capabilities gAtomicMemCap, gAtomicFenceCap; // atomic memory and fence capabilities for this device +cl_half_rounding_mode gHalfRoundingMode = CL_HALF_RTE; +bool gFloatAtomicsSupported = false; +cl_device_fp_atomic_capabilities_ext gHalfAtomicCaps = 0; test_status InitCL(cl_device_id device) { auto version = get_device_cl_version(device); @@ -123,6 +129,34 @@ test_status InitCL(cl_device_id device) { | CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES; } + if (is_extension_available(device, "cl_ext_float_atomics")) + { + gFloatAtomicsSupported = true; + if (is_extension_available(device, "cl_khr_fp16")) + { + cl_int error = clGetDeviceInfo( + device, CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT, + sizeof(gHalfAtomicCaps), &gHalfAtomicCaps, nullptr); + test_error_ret(error, "clGetDeviceInfo failed!", TEST_FAIL); + + const cl_device_fp_config fpConfigHalf = + get_default_rounding_mode(device, CL_DEVICE_HALF_FP_CONFIG); + if ((fpConfigHalf & CL_FP_ROUND_TO_NEAREST) != 0) + { + gHalfRoundingMode = CL_HALF_RTE; + } + else if ((fpConfigHalf & CL_FP_ROUND_TO_ZERO) != 0) + { + gHalfRoundingMode = CL_HALF_RTZ; + } + else + { + log_error("Error while acquiring half rounding mode\n"); + return TEST_FAIL; + } + } + } + return TEST_PASS; } diff --git a/test_conformance/c11_atomics/test_atomics.cpp b/test_conformance/c11_atomics/test_atomics.cpp index 95e0c13f..a08a0daf 100644 --- a/test_conformance/c11_atomics/test_atomics.cpp +++ b/test_conformance/c11_atomics/test_atomics.cpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2017 The Khronos Group Inc. +// 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. @@ -33,6 +33,7 @@ public: using CBasicTestMemOrderScope::MemoryOrderScopeStr; using CBasicTest::CheckCapabilities; + using CBasicTestMemOrderScope::LocalMemory; CBasicTestStore(TExplicitAtomicType dataType, bool useSVM) : CBasicTestMemOrderScope(dataType, useSVM) @@ -54,6 +55,21 @@ public: == TEST_SKIPPED_ITSELF) return 0; // skip test - not applicable + if (CBasicTestMemOrderScope::DataType() + ._type + == TYPE_ATOMIC_HALF) + { + if (LocalMemory() + && (gHalfAtomicCaps & CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT) + == 0) + return 0; // skip test - not applicable + + if (!LocalMemory() + && (gHalfAtomicCaps & CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT) + == 0) + return 0; + } + return CBasicTestMemOrderScope< HostAtomicType, HostDataType>::ExecuteSingleTest(deviceID, context, queue); @@ -75,7 +91,13 @@ public: HostDataType *startRefValues, cl_uint whichDestValue) { - expected = (HostDataType)whichDestValue; + if (CBasicTestMemOrderScope::DataType() + ._type + != TYPE_ATOMIC_HALF) + expected = (HostDataType)whichDestValue; + else + expected = cl_half_from_float(static_cast(whichDestValue), + gHalfRoundingMode); return true; } }; @@ -109,6 +131,15 @@ static int test_atomic_store_generic(cl_device_id deviceID, cl_context context, TYPE_ATOMIC_DOUBLE, useSVM); EXECUTE_TEST(error, test_double.Execute(deviceID, context, queue, num_elements)); + + if (gFloatAtomicsSupported) + { + CBasicTestStore test_half(TYPE_ATOMIC_HALF, + useSVM); + EXECUTE_TEST(error, + test_half.Execute(deviceID, context, queue, num_elements)); + } + if (AtomicTypeInfo(TYPE_ATOMIC_SIZE_T).Size(deviceID) == 4) { CBasicTestStore test_intptr_t( @@ -297,6 +328,7 @@ public: HostDataType>::MemoryOrderScopeStr; using CBasicTestMemOrderScope::MemoryScopeStr; using CBasicTest::CheckCapabilities; + using CBasicTestMemOrderScope::LocalMemory; CBasicTestLoad(TExplicitAtomicType dataType, bool useSVM) : CBasicTestMemOrderScope(dataType, useSVM) @@ -318,6 +350,21 @@ public: == TEST_SKIPPED_ITSELF) return 0; // skip test - not applicable + if (CBasicTestMemOrderScope::DataType() + ._type + == TYPE_ATOMIC_HALF) + { + if (LocalMemory() + && (gHalfAtomicCaps & CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT) + == 0) + return 0; // skip test - not applicable + + if (!LocalMemory() + && (gHalfAtomicCaps & CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT) + == 0) + return 0; + } + return CBasicTestMemOrderScope< HostAtomicType, HostDataType>::ExecuteSingleTest(deviceID, context, queue); @@ -351,7 +398,13 @@ public: HostDataType *startRefValues, cl_uint whichDestValue) { - expected = (HostDataType)whichDestValue; + if (CBasicTestMemOrderScope::DataType() + ._type + != TYPE_ATOMIC_HALF) + expected = (HostDataType)whichDestValue; + else + expected = cl_half_from_float(static_cast(whichDestValue), + gHalfRoundingMode); return true; } virtual bool VerifyRefs(bool &correct, cl_uint threadCount, @@ -361,11 +414,25 @@ public: correct = true; for (cl_uint i = 0; i < threadCount; i++) { - if (refValues[i] != (HostDataType)i) + if constexpr (std::is_same::value) { - log_error("Invalid value for thread %u\n", (cl_uint)i); - correct = false; - return true; + HostDataType test = cl_half_from_float(static_cast(i), + gHalfRoundingMode); + if (refValues[i] != test) + { + log_error("Invalid value for thread %u\n", (cl_uint)i); + correct = false; + return true; + } + } + else + { + if (refValues[i] != (HostDataType)i) + { + log_error("Invalid value for thread %u\n", (cl_uint)i); + correct = false; + return true; + } } } return true; @@ -400,6 +467,15 @@ static int test_atomic_load_generic(cl_device_id deviceID, cl_context context, TYPE_ATOMIC_DOUBLE, useSVM); EXECUTE_TEST(error, test_double.Execute(deviceID, context, queue, num_elements)); + + if (gFloatAtomicsSupported) + { + CBasicTestLoad test_half(TYPE_ATOMIC_HALF, + useSVM); + EXECUTE_TEST(error, + test_half.Execute(deviceID, context, queue, num_elements)); + } + if (AtomicTypeInfo(TYPE_ATOMIC_SIZE_T).Size(deviceID) == 4) { CBasicTestLoad test_intptr_t( @@ -469,11 +545,36 @@ public: HostDataType>::MemoryOrderScopeStr; using CBasicTestMemOrderScope::Iterations; using CBasicTestMemOrderScope::IterationsStr; + using CBasicTestMemOrderScope::LocalMemory; CBasicTestExchange(TExplicitAtomicType dataType, bool useSVM) : CBasicTestMemOrderScope(dataType, useSVM) { - StartValue(123456); + if constexpr (std::is_same_v) + StartValue(cl_half_from_float(static_cast(1234), + gHalfRoundingMode)); + else + StartValue(123456); + } + virtual int ExecuteSingleTest(cl_device_id deviceID, cl_context context, + cl_command_queue queue) + { + if constexpr (std::is_same_v) + { + if (LocalMemory() + && (gHalfAtomicCaps & CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT) + == 0) + return 0; // skip test - not applicable + + if (!LocalMemory() + && (gHalfAtomicCaps & CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT) + == 0) + return 0; + } + + return CBasicTestMemOrderScope< + HostAtomicType, HostDataType>::ExecuteSingleTest(deviceID, context, + queue); } virtual std::string ProgramCore() { @@ -515,17 +616,35 @@ public: /* Any repeated value is treated as an error */ std::vector tidFound(threadCount); bool startValueFound = false; - cl_uint i; + cl_uint startVal = StartValue(); - for (i = 0; i <= threadCount; i++) + if constexpr (std::is_same_v) + startVal = static_cast( + cl_half_to_float(static_cast(StartValue()))); + + for (cl_uint i = 0; i <= threadCount; i++) { - cl_uint value; + cl_uint value = 0; if (i == threadCount) - value = (cl_uint)finalValues[0]; // additional value from atomic + { + if constexpr (!std::is_same_v) + value = + (cl_uint)finalValues[0]; // additional value from atomic // variable (last written) + else + value = + cl_half_to_float(static_cast(finalValues[0])); + } else - value = (cl_uint)refValues[i]; - if (value == (cl_uint)StartValue()) + { + if constexpr (!std::is_same_v) + value = (cl_uint)refValues[i]; + else + value = + cl_half_to_float(static_cast(refValues[i])); + } + + if (value == startVal) { // Special initial value if (startValueFound) @@ -590,6 +709,13 @@ static int test_atomic_exchange_generic(cl_device_id deviceID, TYPE_ATOMIC_DOUBLE, useSVM); EXECUTE_TEST(error, test_double.Execute(deviceID, context, queue, num_elements)); + if (gFloatAtomicsSupported) + { + CBasicTestExchange test_half( + TYPE_ATOMIC_HALF, useSVM); + EXECUTE_TEST(error, + test_half.Execute(deviceID, context, queue, num_elements)); + } if (AtomicTypeInfo(TYPE_ATOMIC_SIZE_T).Size(deviceID) == 4) { CBasicTestExchange diff --git a/test_conformance/common/vulkan_wrapper/CMakeLists.txt b/test_conformance/common/vulkan_wrapper/CMakeLists.txt index c647b4b6..42397998 100644 --- a/test_conformance/common/vulkan_wrapper/CMakeLists.txt +++ b/test_conformance/common/vulkan_wrapper/CMakeLists.txt @@ -6,6 +6,7 @@ set(VULKAN_WRAPPER_SOURCES ) # needed by Vulkan wrapper to compile +set(CMAKE_COMPILE_WARNING_AS_ERROR OFF) add_cxx_flag_if_supported(-Wmisleading-indentation) add_cxx_flag_if_supported(-Wno-narrowing) add_cxx_flag_if_supported(-Wno-format) diff --git a/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp index ded1e709..f4245703 100644 --- a/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp +++ b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.cpp @@ -428,38 +428,68 @@ size_t GetElementNBytes(const cl_image_format *format) return result; } -cl_int get2DImageDimensions(const VkImageCreateInfo *VulkanImageCreateInfo, - cl_image_format *img_fmt, size_t totalImageSize, - size_t &width, size_t &height) +cl_int getImageDimensions(const VkImageCreateInfo *VulkanImageCreateInfo, + cl_image_format *img_fmt, cl_image_desc *img_desc, + VkExtent3D max_ext, const VkSubresourceLayout *layout) { - cl_int result = CL_SUCCESS; - if (totalImageSize == 0) + test_assert_error( + VulkanImageCreateInfo != nullptr, + "getImageDimensions: invalid VulkanImageCreateInfo pointer!"); + test_assert_error(img_fmt != nullptr, + "getImageDimensions: invalid img_fmt pointer!"); + test_assert_error(img_desc != nullptr, + "getImageDimensions: invalid img_desc pointer!"); + + img_desc->image_depth = VulkanImageCreateInfo->extent.depth; + img_desc->image_width = VulkanImageCreateInfo->extent.width; + img_desc->image_height = VulkanImageCreateInfo->extent.height; + + if (layout != nullptr) { - result = CL_INVALID_VALUE; + size_t element_size = GetElementNBytes(img_fmt); + size_t row_pitch = element_size * VulkanImageCreateInfo->extent.width; + row_pitch = row_pitch < layout->rowPitch ? layout->rowPitch : row_pitch; + img_desc->image_row_pitch = row_pitch; + + size_t slice_pitch = row_pitch * VulkanImageCreateInfo->extent.height; + slice_pitch = + slice_pitch < layout->depthPitch ? layout->depthPitch : slice_pitch; + img_desc->image_slice_pitch = slice_pitch; } - size_t element_size = GetElementNBytes(img_fmt); - size_t row_pitch = element_size * VulkanImageCreateInfo->extent.width; - row_pitch = row_pitch % 64 == 0 ? row_pitch : ((row_pitch / 64) + 1) * 64; - width = row_pitch / element_size; - height = totalImageSize / row_pitch; + switch (img_desc->image_type) + { + case CL_MEM_OBJECT_IMAGE3D: + test_assert_error(img_desc->image_depth >= 1 + && img_desc->image_depth <= max_ext.depth, + "getImageDimensions: invalid image depth!"); + case CL_MEM_OBJECT_IMAGE2D: + test_assert_error(img_desc->image_height >= 1 + && img_desc->image_height <= max_ext.height, + "getImageDimensions: invalid image height!"); + case CL_MEM_OBJECT_IMAGE1D: + test_assert_error(img_desc->image_width >= 1 + && img_desc->image_width <= max_ext.width, + "getImageDimensions: invalid image width!"); + } - return result; + return CL_SUCCESS; } cl_int -getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *VulkanImageCreateInfo, - size_t totalImageSize, cl_image_format *img_fmt, - cl_image_desc *img_desc) +getCLImageInfoFromVkImageInfo(const cl_device_id device, + const VkImageCreateInfo *VulkanImageCreateInfo, + cl_image_format *img_fmt, cl_image_desc *img_desc, + const VkSubresourceLayout *layout) { - cl_int result = CL_SUCCESS; + cl_int error = CL_SUCCESS; cl_image_format clImgFormat = { 0 }; - result = + error = getCLFormatFromVkFormat(VulkanImageCreateInfo->format, &clImgFormat); - if (CL_SUCCESS != result) + if (CL_SUCCESS != error) { - return result; + return error; } memcpy(img_fmt, &clImgFormat, sizeof(cl_image_format)); @@ -469,25 +499,57 @@ getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *VulkanImageCreateInfo, return CL_INVALID_VALUE; } - result = - get2DImageDimensions(VulkanImageCreateInfo, img_fmt, totalImageSize, - img_desc->image_width, img_desc->image_height); - if (CL_SUCCESS != result) + VkExtent3D max_ext = { 0, 0, 0 }; + + size_t width = 0, height = 0, depth = 0; + if (img_desc->image_type == CL_MEM_OBJECT_IMAGE3D) { - throw std::runtime_error("get2DImageDimensions failed!!!"); + error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH, + sizeof(width), &width, NULL); + test_error(error, "Unable to get CL_DEVICE_IMAGE3D_MAX_WIDTH"); + error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, + sizeof(height), &height, NULL); + test_error(error, "Unable to get CL_DEVICE_IMAGE3D_MAX_HEIGHT"); + error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH, + sizeof(depth), &depth, NULL); + test_error(error, "Unable to get CL_DEVICE_IMAGE3D_MAX_DEPTH"); + } + else + { + error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH, + sizeof(width), &width, NULL); + test_error(error, "Unable to get CL_DEVICE_IMAGE2D_MAX_WIDTH"); + error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, + sizeof(height), &height, NULL); + test_error(error, "Unable to get CL_DEVICE_IMAGE2D_MAX_HEIGHT"); + } + + max_ext.depth = depth; + max_ext.height = height; + max_ext.width = width; + + // If image_row_pitch is zero and the image is created from an external + // memory handle, then the image row pitch is implementation-defined + img_desc->image_row_pitch = 0; + // If image_slice_pitch is zero and the image is created from an external + // memory handle, then the image slice pitch is implementation-defined + img_desc->image_slice_pitch = 0; + + error = getImageDimensions(VulkanImageCreateInfo, img_fmt, img_desc, + max_ext, layout); + if (CL_SUCCESS != error) + { + throw std::runtime_error("getImageDimensions failed!!!"); } img_desc->image_depth = static_cast(VulkanImageCreateInfo->extent.depth); img_desc->image_array_size = 0; - img_desc->image_row_pitch = 0; // Row pitch set to zero as host_ptr is NULL - img_desc->image_slice_pitch = - img_desc->image_row_pitch * img_desc->image_height; img_desc->num_mip_levels = 0; img_desc->num_samples = 0; img_desc->buffer = NULL; - return result; + return error; } cl_int check_external_memory_handle_type( @@ -529,8 +591,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 +602,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 +611,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) @@ -705,13 +773,17 @@ clExternalMemoryImage::clExternalMemoryImage( std::vector extMemProperties1; cl_device_id devList[] = { deviceId, NULL }; - VulkanImageTiling vulkanImageTiling = - vkClExternalMemoryHandleTilingAssumption( - deviceId, externalMemoryHandleType, &errcode_ret); + auto vulkanImageTiling = vkClExternalMemoryHandleTilingAssumption( + deviceId, externalMemoryHandleType, &errcode_ret); if (CL_SUCCESS != errcode_ret) { throw std::runtime_error("Failed to query OpenCL tiling mode"); } + if (vulkanImageTiling == std::nullopt) + { + throw std::runtime_error( + "Could not find image tiling supported by both Vulkan and OpenCL"); + } #ifdef _WIN32 if (!is_extension_available(devList[0], "cl_khr_external_memory_win32")) @@ -796,7 +868,7 @@ clExternalMemoryImage::clExternalMemoryImage( image2D.getVkImageCreateInfo(); errcode_ret = getCLImageInfoFromVkImageInfo( - &VulkanImageCreateInfo, image2D.getSize(), &img_format, &image_desc); + deviceId, &VulkanImageCreateInfo, &img_format, &image_desc); if (CL_SUCCESS != errcode_ret) { throw std::runtime_error("getCLImageInfoFromVkImageInfo failed\n"); @@ -855,9 +927,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; @@ -875,8 +953,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); @@ -888,8 +964,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); @@ -903,8 +977,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); @@ -924,21 +996,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_HANDLE_SYNC_FD_KHR)); sema_props.push_back(static_cast(-1)); break; + default: log_error("Unsupported external memory handle type\n"); ASSERT(0); @@ -1013,11 +1081,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; @@ -1191,6 +1263,10 @@ cl_external_memory_handle_type_khr vkToOpenCLExternalMemoryHandleType( { switch (vkExternalMemoryHandleType) { + default: + case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: + log_error("Unexpected external memory handle type\n"); + return 0; case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: return CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR; case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT: @@ -1198,17 +1274,17 @@ cl_external_memory_handle_type_khr vkToOpenCLExternalMemoryHandleType( case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT: return CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR; - case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: return 0; + case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_NAME: + return CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_NAME_KHR; } return 0; } -VulkanImageTiling vkClExternalMemoryHandleTilingAssumption( +std::optional vkClExternalMemoryHandleTilingAssumption( cl_device_id deviceId, VulkanExternalMemoryHandleType vkExternalMemoryHandleType, int *error_ret) { size_t size = 0; - VulkanImageTiling mode = VULKAN_IMAGE_TILING_OPTIMAL; assert(error_ret != nullptr); // errcode_ret is not optional, it must be checked @@ -1219,12 +1295,12 @@ VulkanImageTiling vkClExternalMemoryHandleTilingAssumption( 0, nullptr, &size); if (*error_ret != CL_SUCCESS) { - return mode; + return std::nullopt; } if (size == 0) { - return mode; + return std::nullopt; } std::vector assume_linear_types( @@ -1236,7 +1312,7 @@ VulkanImageTiling vkClExternalMemoryHandleTilingAssumption( size, assume_linear_types.data(), nullptr); if (*error_ret != CL_SUCCESS) { - return mode; + return std::nullopt; } if (std::find( @@ -1244,8 +1320,8 @@ VulkanImageTiling vkClExternalMemoryHandleTilingAssumption( vkToOpenCLExternalMemoryHandleType(vkExternalMemoryHandleType)) != assume_linear_types.end()) { - mode = VULKAN_IMAGE_TILING_LINEAR; + return VULKAN_IMAGE_TILING_LINEAR; } - return mode; + return std::nullopt; } diff --git a/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp index 43912d5a..f9a305e1 100644 --- a/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp +++ b/test_conformance/common/vulkan_wrapper/opencl_vulkan_wrapper.hpp @@ -26,22 +26,7 @@ #include #endif -#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); \ - } +#include typedef cl_semaphore_khr (*pfnclCreateSemaphoreWithPropertiesKHR)( cl_context context, cl_semaphore_properties_khr *sema_props, @@ -86,16 +71,17 @@ extern pfnclEnqueueReleaseExternalMemObjectsKHR extern pfnclReleaseSemaphoreKHR clReleaseSemaphoreKHRptr; extern pfnclReImportSemaphoreSyncFdKHR pfnclReImportSemaphoreSyncFdKHRptr; -cl_int getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *, size_t, - cl_image_format *, cl_image_desc *); +cl_int +getCLImageInfoFromVkImageInfo(const cl_device_id, const VkImageCreateInfo *, + cl_image_format *, cl_image_desc *, + const VkSubresourceLayout *layout = nullptr); 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); @@ -187,8 +173,8 @@ public: extern void init_cl_vk_ext(cl_platform_id, cl_uint num_devices, cl_device_id *deviceIds); -VulkanImageTiling vkClExternalMemoryHandleTilingAssumption( +std::optional vkClExternalMemoryHandleTilingAssumption( cl_device_id deviceId, VulkanExternalMemoryHandleType vkExternalMemoryHandleType, int *error_ret); -#endif // _opencl_vulkan_wrapper_hpp_ \ No newline at end of file +#endif // _opencl_vulkan_wrapper_hpp_ diff --git a/test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp b/test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp index f5e7437a..a474102d 100644 --- a/test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_api_list.hpp @@ -102,6 +102,8 @@ VK_FUNC_DECL(vkImportSemaphoreFdKHR) \ VK_FUNC_DECL(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR) \ VK_FUNC_DECL(vkGetImageSubresourceLayout) \ + VK_FUNC_DECL(vkCreateDebugUtilsMessengerEXT) \ + VK_FUNC_DECL(vkDestroyDebugUtilsMessengerEXT) \ VK_FUNC_DECL(vkGetPhysicalDeviceExternalBufferProperties) #define VK_WINDOWS_FUNC_LIST \ VK_FUNC_DECL(vkGetMemoryWin32HandleKHR) \ @@ -203,6 +205,8 @@ #define vkGetSemaphoreWin32HandleKHR _vkGetSemaphoreWin32HandleKHR #define vkImportSemaphoreWin32HandleKHR _vkImportSemaphoreWin32HandleKHR #define vkGetImageSubresourceLayout _vkGetImageSubresourceLayout +#define vkCreateDebugUtilsMessengerEXT _vkCreateDebugUtilsMessengerEXT +#define vkDestroyDebugUtilsMessengerEXT _vkDestroyDebugUtilsMessengerEXT #define vkGetPhysicalDeviceExternalBufferProperties \ _vkGetPhysicalDeviceExternalBufferProperties diff --git a/test_conformance/common/vulkan_wrapper/vulkan_utility.cpp b/test_conformance/common/vulkan_wrapper/vulkan_utility.cpp index 6391d36b..75aa536d 100644 --- a/test_conformance/common/vulkan_wrapper/vulkan_utility.cpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_utility.cpp @@ -32,13 +32,13 @@ #define BUFFERSIZE 3000 -const VulkanInstance &getVulkanInstance() +const VulkanInstance &getVulkanInstance(bool useValidationLayers) { - static VulkanInstance instance; + static VulkanInstance instance(useValidationLayers); return instance; } -const VulkanPhysicalDevice &getVulkanPhysicalDevice() +const VulkanPhysicalDevice &getVulkanPhysicalDevice(bool useValidationLayers) { size_t pdIdx = 0; cl_int errNum = 0; @@ -47,7 +47,7 @@ const VulkanPhysicalDevice &getVulkanPhysicalDevice() cl_uint num_devices = 0; cl_uint device_no = 0; const size_t bufsize = BUFFERSIZE; - const VulkanInstance &instance = getVulkanInstance(); + const VulkanInstance &instance = getVulkanInstance(useValidationLayers); const VulkanPhysicalDeviceList &physicalDeviceList = instance.getPhysicalDeviceList(); @@ -112,12 +112,13 @@ const VulkanPhysicalDevice &getVulkanPhysicalDevice() } const VulkanPhysicalDevice & -getAssociatedVulkanPhysicalDevice(cl_device_id deviceId) +getAssociatedVulkanPhysicalDevice(cl_device_id deviceId, + bool useValidationLayers) { size_t pdIdx; cl_int errNum = 0; cl_uchar uuid[CL_UUID_SIZE_KHR]; - const VulkanInstance &instance = getVulkanInstance(); + const VulkanInstance &instance = getVulkanInstance(useValidationLayers); const VulkanPhysicalDeviceList &physicalDeviceList = instance.getPhysicalDeviceList(); @@ -188,10 +189,10 @@ getVulkanMemoryType(const VulkanDevice &device, return memoryTypeList[mtIdx]; } -bool checkVkSupport() +bool checkVkSupport(bool useValidationLayers) { bool result = true; - const VulkanInstance &instance = getVulkanInstance(); + const VulkanInstance &instance = getVulkanInstance(useValidationLayers); const VulkanPhysicalDeviceList &physicalDeviceList = instance.getPhysicalDeviceList(); if (physicalDeviceList() == NULL) @@ -711,6 +712,7 @@ operator<<(std::ostream &os, { switch (externalMemoryHandleType) { + default: case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: return os << "None"; case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: return os << "Opaque file descriptor"; @@ -731,6 +733,7 @@ operator<<(std::ostream &os, { switch (externalSemaphoreHandleType) { + default: case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE: return os << "None"; case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: return os << "Opaque file descriptor"; diff --git a/test_conformance/common/vulkan_wrapper/vulkan_utility.hpp b/test_conformance/common/vulkan_wrapper/vulkan_utility.hpp index 85028662..cd9bf4ee 100644 --- a/test_conformance/common/vulkan_wrapper/vulkan_utility.hpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_utility.hpp @@ -30,10 +30,12 @@ #define ROUND_UP(n, multiple) \ (((n) + (multiple)-1) - ((((n) + (multiple)-1)) % (multiple))) -const VulkanInstance& getVulkanInstance(); -const VulkanPhysicalDevice& getVulkanPhysicalDevice(); +const VulkanInstance& getVulkanInstance(bool useValidationLayers = false); const VulkanPhysicalDevice& -getAssociatedVulkanPhysicalDevice(cl_device_id deviceId); +getVulkanPhysicalDevice(bool useValidationLayers = false); +const VulkanPhysicalDevice& +getAssociatedVulkanPhysicalDevice(cl_device_id deviceId, + bool useValidationLayers = false); const VulkanQueueFamily& getVulkanQueueFamily( const VulkanPhysicalDevice& physicalDevice = getVulkanPhysicalDevice(), uint32_t queueFlags = VULKAN_QUEUE_FLAG_GRAPHICS @@ -41,7 +43,7 @@ const VulkanQueueFamily& getVulkanQueueFamily( const VulkanMemoryType& getVulkanMemoryType(const VulkanDevice& device, VulkanMemoryTypeProperty memoryTypeProperty); -bool checkVkSupport(); +bool checkVkSupport(bool useValidationLayers = false); const VulkanQueueFamilyList& getEmptyVulkanQueueFamilyList(); const VulkanDescriptorSetLayoutList& getEmptyVulkanDescriptorSetLayoutList(); const VulkanQueueFamilyToQueueCountMap& diff --git a/test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp b/test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp index 6c31a35d..7254742d 100644 --- a/test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_wrapper.cpp @@ -48,16 +48,38 @@ VK_WINDOWS_FUNC_LIST #define CHECK_VK(call) \ if (call != VK_SUCCESS) return call; + +static VKAPI_ATTR VkBool32 VKAPI_CALL logCallback( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData) +{ + switch (messageSeverity) + { + case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: + log_error("Vulkan validation layer: %s\n", pCallbackData->pMessage); + break; + default: + log_info("Vulkan validation layer: %s\n", pCallbackData->pMessage); + break; + } + + return VK_FALSE; +} + /////////////////////////////////// // VulkanInstance implementation // /////////////////////////////////// VulkanInstance::VulkanInstance(const VulkanInstance &instance) : m_vkInstance(instance.m_vkInstance), - m_physicalDeviceList(instance.m_physicalDeviceList) + m_physicalDeviceList(instance.m_physicalDeviceList), + m_useValidationLayers(instance.m_useValidationLayers), + m_validationLayers(instance.m_validationLayers) {} -VulkanInstance::VulkanInstance(): m_vkInstance(VK_NULL_HANDLE) +VulkanInstance::VulkanInstance(bool useValidationLayers) + : m_vkInstance(VK_NULL_HANDLE), m_useValidationLayers(useValidationLayers) { #if defined(__linux__) && !defined(__ANDROID__) char *glibcVersion = strdup(gnu_get_libc_version()); @@ -130,6 +152,35 @@ VulkanInstance::VulkanInstance(): m_vkInstance(VK_NULL_HANDLE) VK_GET_NULL_INSTANCE_PROC_ADDR(vkCreateInstance); #undef VK_GET_NULL_INSTANCE_PROC_ADDR + if (m_useValidationLayers) + { + uint32_t layerCount = 0; + vkEnumerateInstanceLayerProperties(&layerCount, nullptr); + + std::vector layers(layerCount); + vkEnumerateInstanceLayerProperties(&layerCount, layers.data()); + + for (auto it = m_validationLayers.begin(); + it != m_validationLayers.end();) + { + bool found = false; + for (const auto &layerProps : layers) + if (strcmp(*it, layerProps.layerName) == 0) + { + found = true; + break; + } + if (!found) + { + log_info("Vulkan layer not found: %s\n", *it); + it = m_validationLayers.erase(it); + } + else + ++it; + } + m_useValidationLayers = !m_validationLayers.empty(); + } + VkApplicationInfo vkApplicationInfo = {}; vkApplicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; vkApplicationInfo.pNext = NULL; @@ -147,6 +198,9 @@ VulkanInstance::VulkanInstance(): m_vkInstance(VK_NULL_HANDLE) enabledExtensionNameList.push_back( VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME); + if (m_useValidationLayers) + enabledExtensionNameList.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + std::vector vkExtensionPropertiesList( instanceExtensionPropertiesCount); vkEnumerateInstanceExtensionProperties(NULL, @@ -174,18 +228,51 @@ VulkanInstance::VulkanInstance(): m_vkInstance(VK_NULL_HANDLE) VkInstanceCreateInfo vkInstanceCreateInfo = {}; vkInstanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; - vkInstanceCreateInfo.pNext = NULL; vkInstanceCreateInfo.flags = 0; vkInstanceCreateInfo.pApplicationInfo = &vkApplicationInfo; - vkInstanceCreateInfo.enabledLayerCount = 0; vkInstanceCreateInfo.ppEnabledLayerNames = NULL; vkInstanceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensionNameList.size(); vkInstanceCreateInfo.ppEnabledExtensionNames = enabledExtensionNameList.data(); + vkInstanceCreateInfo.enabledLayerCount = 0; + vkInstanceCreateInfo.pNext = NULL; + + VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{}; + if (m_useValidationLayers) + { + vkInstanceCreateInfo.enabledLayerCount = + static_cast(m_validationLayers.size()); + vkInstanceCreateInfo.ppEnabledLayerNames = m_validationLayers.data(); + + debugCreateInfo.messageType = + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + + debugCreateInfo.sType = + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + debugCreateInfo.messageSeverity = + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT + | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + debugCreateInfo.pfnUserCallback = logCallback; + + vkInstanceCreateInfo.pNext = + (VkDebugUtilsMessengerCreateInfoEXT *)&debugCreateInfo; + } vkCreateInstance(&vkInstanceCreateInfo, NULL, &m_vkInstance); + if (m_useValidationLayers) + { + _vkCreateDebugUtilsMessengerEXT = + (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr( + m_vkInstance, "vkCreateDebugUtilsMessengerEXT"); + if (_vkCreateDebugUtilsMessengerEXT != nullptr) + vkCreateDebugUtilsMessengerEXT(m_vkInstance, &debugCreateInfo, + nullptr, &m_debugMessenger); + } + #define VK_FUNC_DECL(name) \ _##name = (PFN_##name)vkGetInstanceProcAddr(m_vkInstance, #name); \ // ASSERT_NEQ((unsigned long long)name, 0ULL) << "Couldn't obtain address @@ -228,6 +315,17 @@ VulkanInstance::~VulkanInstance() m_physicalDeviceList[pdIdx]; delete &physicalDevice; } + + _vkDestroyDebugUtilsMessengerEXT = + (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr( + m_vkInstance, "vkDestroyDebugUtilsMessengerEXT"); + + if (_vkDestroyDebugUtilsMessengerEXT != nullptr) + { + vkDestroyDebugUtilsMessengerEXT(m_vkInstance, m_debugMessenger, + nullptr); + } + if (m_vkInstance) { vkDestroyInstance(m_vkInstance, NULL); @@ -1741,7 +1839,13 @@ VulkanImage::VulkanImage( vkImageCreateInfo.pNext = &vkExternalMemoryImageCreateInfo; } - vkCreateImage(m_device, &vkImageCreateInfo, NULL, &m_vkImage); + VkResult vkStatus = + vkCreateImage(m_device, &vkImageCreateInfo, NULL, &m_vkImage); + if (vkStatus != VK_SUCCESS) + { + throw std::runtime_error("Error: Failed create image."); + } + VulkanImageCreateInfo = vkImageCreateInfo; VkMemoryDedicatedRequirements vkMemoryDedicatedRequirements = {}; @@ -1870,7 +1974,7 @@ VulkanExtent3D VulkanImage2D::getExtent3D(uint32_t mipLevel) const return VulkanExtent3D(width, height, depth); } -VkSubresourceLayout VulkanImage2D::getSubresourceLayout() const +VkSubresourceLayout VulkanImage::getSubresourceLayout() const { VkImageSubresource subresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0 }; diff --git a/test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp b/test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp index a536d140..9cb031f5 100644 --- a/test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp +++ b/test_conformance/common/vulkan_wrapper/vulkan_wrapper.hpp @@ -25,14 +25,21 @@ #include class VulkanInstance { - friend const VulkanInstance &getVulkanInstance(); + friend const VulkanInstance &getVulkanInstance(bool useValidationLayers); protected: VkInstance m_vkInstance; VulkanPhysicalDeviceList m_physicalDeviceList; + VkDebugUtilsMessengerEXT m_debugMessenger; + bool m_useValidationLayers; + std::vector m_validationLayers = { + "VK_LAYER_KHRONOS_validation", + }; - VulkanInstance(); VulkanInstance(const VulkanInstance &); + +public: + VulkanInstance(bool useValidationLayers = false); virtual ~VulkanInstance(); public: @@ -478,12 +485,14 @@ public: VulkanExternalMemoryHandleType externalMemoryHandleType = VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE, VulkanImageCreateFlag imageCreateFlags = VULKAN_IMAGE_CREATE_FLAG_NONE, - VulkanImageTiling imageTiling = VULKAN_IMAGE_TILING_OPTIMAL, + VulkanImageTiling imageTiling = VULKAN_IMAGE_TILING_LINEAR, VulkanImageUsage imageUsage = VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST, VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE); virtual ~VulkanImage(); virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const; + virtual VkSubresourceLayout getSubresourceLayout() const; + VulkanFormat getFormat() const; uint32_t getNumMipLevels() const; uint32_t getNumLayers() const; @@ -553,7 +562,6 @@ public: VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE); virtual ~VulkanImage2D(); virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const; - virtual VkSubresourceLayout getSubresourceLayout() const; VulkanImage2D(const VulkanImage2D &image2D); }; diff --git a/test_conformance/compiler/testBase.h b/test_conformance/compiler/testBase.h index 70c42b5d..9a9591b7 100644 --- a/test_conformance/compiler/testBase.h +++ b/test_conformance/compiler/testBase.h @@ -45,27 +45,4 @@ } -// scope guard helper to ensure proper releasing of sub devices -struct SubDevicesScopeGuarded -{ - SubDevicesScopeGuarded(const cl_int dev_count) - { - sub_devices.resize(dev_count); - } - ~SubDevicesScopeGuarded() - { - for (auto &device : sub_devices) - { - cl_int err = clReleaseDevice(device); - if (err != CL_SUCCESS) - log_error("\n Releasing sub-device failed \n"); - } - } - - std::vector sub_devices; -}; - #endif // _testBase_h - - - diff --git a/test_conformance/compiler/test_build_helpers.cpp b/test_conformance/compiler/test_build_helpers.cpp index a4945350..e8ef3ee8 100644 --- a/test_conformance/compiler/test_build_helpers.cpp +++ b/test_conformance/compiler/test_build_helpers.cpp @@ -55,7 +55,6 @@ const char *sample_kernel_code_two_line[] = { "\n" "}\n" }; - const char *sample_kernel_code_bad_multi_line[] = { "__kernel void sample_test(__global float *src, __global int *dst)", "{", @@ -87,6 +86,35 @@ __kernel void sample_test_C(__global float *src, __global int *dst) } )"; +const char *sample_multi_kernel_code_AB_with_macro = R"( +__kernel void sample_test_A(__global float *src, __global int *dst) +{ + size_t tid = get_global_id(0); + dst[tid] = (int)src[tid]; +} +#ifdef USE_SAMPLE_TEST_B +__kernel void sample_test_B(__global float *src, __global int *dst) +{ + size_t tid = get_global_id(0); + dst[tid] = (int)src[tid]; +} +#endif +)"; + +const char *sample_multi_kernel_code_CD_with_macro = R"( +__kernel void sample_test_C(__global float *src, __global int *dst) +{ + size_t tid = get_global_id(0); + dst[tid] = (int)src[tid]; +} +#ifdef USE_SAMPLE_TEST_D +__kernel void sample_test_D(__global float *src, __global int *dst) +{ + size_t tid = get_global_id(0); + dst[tid] = (int)src[tid]; +} +#endif +)"; REGISTER_TEST(load_program_source) { @@ -550,6 +578,128 @@ REGISTER_TEST(get_program_info_kernel_names) return CL_SUCCESS; } +REGISTER_TEST(get_linked_program_info_kernel_names) +{ + int error = CL_SUCCESS; + size_t total_kernels = 0; + size_t kernel_names_len = 0; + + clProgramWrapper program_AB = clCreateProgramWithSource( + context, 1, &sample_multi_kernel_code_AB_with_macro, nullptr, &error); + test_error(error, "clCreateProgramWithSource failed"); + + clProgramWrapper program_CD = clCreateProgramWithSource( + context, 1, &sample_multi_kernel_code_CD_with_macro, nullptr, &error); + test_error(error, "clCreateProgramWithSource failed"); + + clProgramWrapper program = nullptr; + + // 1) Compile and link the programs with the preprocessor macro undefined. + // Query CL_PROGRAM_NUM_KERNELS and check that the correct number is + // returned. Query CL_PROGRAM_KERNEL_NAMES and check that the right + // kernel names are returned. + { + error = + clCompileProgram(program_AB, 1, &device, nullptr, 0, 0, 0, 0, 0); + test_error(error, "clCompileProgram failed"); + + error = + clCompileProgram(program_CD, 1, &device, nullptr, 0, 0, 0, 0, 0); + test_error(error, "clCompileProgram failed"); + + cl_program progs[] = { program_AB, program_CD }; + program = + clLinkProgram(context, 1, &device, "", 2, progs, 0, 0, &error); + test_error(error, "clLinkProgram failed"); + + error = clGetProgramInfo(program, CL_PROGRAM_NUM_KERNELS, + sizeof(size_t), &total_kernels, nullptr); + test_error(error, "clGetProgramInfo failed"); + + test_assert_error(total_kernels == 2, + "Unexpected clGetProgramInfo result"); + + error = clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, 0, nullptr, + &kernel_names_len); + test_error(error, "clGetProgramInfo failed"); + + const size_t len = kernel_names_len + 1; + std::vector kernel_names(len, '\0'); + error = + clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, kernel_names_len, + kernel_names.data(), &kernel_names_len); + test_error(error, "Unable to get kernel names list."); + std::string program_names = kernel_names.data(); + + std::vector expected_names = { "sample_test_A", + "sample_test_C" }; + for (const auto &name : expected_names) + { + test_assert_error(program_names.find(name) != std::string::npos, + "Unexpected kernel name"); + } + + std::vector unexpected_names = { "sample_test_B", + "sample_test_D" }; + for (const auto &name : unexpected_names) + { + test_assert_error(program_names.find(name) == std::string::npos, + "Unexpected kernel name"); + } + } + + // 2) Compile and link the programs with the preprocessor macro defined. + // Query CL_PROGRAM_NUM_KERNELS and check that the correct number is + // returned. Query CL_PROGRAM_KERNEL_NAMES and check that the right + // kernel names are returned. + { + const char *build_options_B = "-DUSE_SAMPLE_TEST_B"; + error = clCompileProgram(program_AB, 1, &device, build_options_B, 0, 0, + 0, 0, 0); + test_error(error, "clCompileProgram failed"); + + const char *build_options_D = "-DUSE_SAMPLE_TEST_D"; + error = clCompileProgram(program_CD, 1, &device, build_options_D, 0, 0, + 0, 0, 0); + test_error(error, "clCompileProgram failed"); + + cl_program progs[] = { program_AB, program_CD }; + program = + clLinkProgram(context, 1, &device, "", 2, progs, 0, 0, &error); + test_error(error, "clLinkProgram failed"); + + error = clGetProgramInfo(program, CL_PROGRAM_NUM_KERNELS, + sizeof(size_t), &total_kernels, nullptr); + test_error(error, "clGetProgramInfo failed"); + + test_assert_error(total_kernels == 4, + "Unexpected clGetProgramInfo result"); + + error = clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, 0, nullptr, + &kernel_names_len); + test_error(error, "clGetProgramInfo failed"); + + std::vector expected_names = { + "sample_test_A", "sample_test_B", "sample_test_C", "sample_test_D" + }; + + const size_t len = kernel_names_len + 1; + std::vector kernel_names(len, '\0'); + error = + clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, kernel_names_len, + kernel_names.data(), &kernel_names_len); + test_error(error, "Could not find expected kernel name"); + + std::string program_names = kernel_names.data(); + for (const auto &name : expected_names) + { + test_assert_error(program_names.find(name) != std::string::npos, + "Unexpected kernel name"); + } + } + return TEST_PASS; +} + REGISTER_TEST(get_program_info_mult_devices) { size_t size = 0; @@ -641,7 +791,7 @@ REGISTER_TEST(get_program_info_mult_devices) if (program == nullptr) { log_error("ERROR: Unable to create reference program!\n"); - return -1; + return TEST_FAIL; } err = clGetProgramInfo(program, CL_PROGRAM_NUM_DEVICES, sizeof(num_devices), @@ -670,7 +820,7 @@ REGISTER_TEST(get_program_info_mult_devices) } } test_error_fail( - !found, "Unexpected result returned by CL_CONTEXT_DEVICES query"); + !found, "Unexpected result returned by CL_PROGRAM_DEVICES query"); } return TEST_PASS; diff --git a/test_conformance/compiler/test_compiler_defines_for_extensions.cpp b/test_conformance/compiler/test_compiler_defines_for_extensions.cpp index c5c62e17..baede608 100644 --- a/test_conformance/compiler/test_compiler_defines_for_extensions.cpp +++ b/test_conformance/compiler/test_compiler_defines_for_extensions.cpp @@ -94,7 +94,8 @@ const char *known_extensions[] = { "cl_khr_external_memory_dma_buf", "cl_khr_command_buffer", "cl_khr_command_buffer_mutable_dispatch", - "cl_khr_command_buffer_multi_device" + "cl_khr_command_buffer_multi_device", + "cl_khr_external_memory_android_hardware_buffer" }; // clang-format on diff --git a/test_conformance/compiler/test_opencl_c_versions.cpp b/test_conformance/compiler/test_opencl_c_versions.cpp index 5b24160f..f53f7b71 100644 --- a/test_conformance/compiler/test_opencl_c_versions.cpp +++ b/test_conformance/compiler/test_opencl_c_versions.cpp @@ -56,9 +56,9 @@ static int test_CL_DEVICE_OPENCL_C_VERSION(cl_device_id device, // For OpenCL 2.x, the minimum required OpenCL C version is OpenCL C 2.0. // For other OpenCL versions, the minimum required OpenCL C version is // the same as the API version. - const Version min_clc_version = api_version == Version(3, 0) - ? Version(1, 2) - : api_version >= Version(2, 0) ? Version(2, 0) : api_version; + const Version min_clc_version = api_version == Version(3, 0) ? Version(1, 2) + : api_version >= Version(2, 0) ? Version(2, 0) + : api_version; if (clc_version < min_clc_version) { log_error("The minimum required OpenCL C version for API version %s is " @@ -88,10 +88,10 @@ static int test_CL_DEVICE_OPENCL_C_VERSION(cl_device_id device, if (clc_version >= testcase.version) { clProgramWrapper program; - cl_int error = - create_single_kernel_helper_create_program_for_device( - context, device, &program, 1, &test_kernel, - testcase.buildOptions); + clKernelWrapper kernel; + cl_int error = create_single_kernel_helper( + context, &program, &kernel, 1, &test_kernel, "test", + testcase.buildOptions); test_error(error, "Unable to build program!"); log_info(" successfully built program with build options '%s'\n", @@ -152,9 +152,10 @@ static int test_CL_DEVICE_OPENCL_C_ALL_VERSIONS(cl_device_id device, buildOptions += std::to_string(minor); clProgramWrapper program; - error = create_single_kernel_helper_create_program_for_device( - context, device, &program, 1, &test_kernel, - buildOptions.c_str()); + clKernelWrapper kernel; + error = create_single_kernel_helper(context, &program, &kernel, 1, + &test_kernel, "test", + buildOptions.c_str()); test_error(error, "Unable to build program!"); log_info(" successfully built program with build options '%s'\n", diff --git a/test_conformance/conversions/CMakeLists.txt b/test_conformance/conversions/CMakeLists.txt index 037430ef..32990eba 100644 --- a/test_conformance/conversions/CMakeLists.txt +++ b/test_conformance/conversions/CMakeLists.txt @@ -12,6 +12,6 @@ if("${CLConform_TARGET_ARCH}" STREQUAL "ARM" OR "${CLConform_TARGET_ARCH}" STREQ list(APPEND ${MODULE_NAME}_SOURCES fplib.cpp) endif() -set_gnulike_module_compile_flags("-Wno-sign-compare -Wno-format") +set_gnulike_module_compile_flags("-Wno-sign-compare") include(../CMakeCommon.txt) diff --git a/test_conformance/conversions/basic_test_conversions.cpp b/test_conformance/conversions/basic_test_conversions.cpp index edad671b..59d41e55 100644 --- a/test_conformance/conversions/basic_test_conversions.cpp +++ b/test_conformance/conversions/basic_test_conversions.cpp @@ -68,12 +68,6 @@ cl_context gContext = NULL; cl_command_queue gQueue = NULL; int gStartTestNumber = -1; int gEndTestNumber = 0; -#if defined(__APPLE__) -int gTimeResults = 1; -#else -int gTimeResults = 0; -#endif -int gReportAverageTimes = 0; void *gIn = NULL; void *gRef = NULL; void *gAllowZ = NULL; @@ -103,8 +97,6 @@ const char **argList = NULL; int argCount = 0; -double SubtractTime(uint64_t endTime, uint64_t startTime); - cl_half_rounding_mode DataInitInfo::halfRoundingMode = CL_HALF_RTE; cl_half_rounding_mode ConversionsTest::defaultHalfRoundingMode = CL_HALF_RTE; @@ -318,7 +310,7 @@ int CalcRefValsPat::check_result(void *test, { const cl_uchar *a = (const cl_uchar *)gAllowZ; - if (is_half()) + if constexpr (is_half()) { const cl_half *t = (const cl_half *)test; const cl_half *c = (const cl_half *)gRef; @@ -335,7 +327,7 @@ int CalcRefValsPat::check_result(void *test, return i + 1; } } - else if (std::is_integral::value) + else if constexpr (std::is_integral::value) { // char/uchar/short/ushort/half/int/uint/long/ulong const OutType *t = (const OutType *)test; const OutType *c = (const OutType *)gRef; @@ -350,7 +342,7 @@ int CalcRefValsPat::check_result(void *test, return i + 1; } } - else if (std::is_same::value) + else if constexpr (std::is_same::value) { // cast to integral - from original test const cl_uint *t = (const cl_uint *)test; @@ -904,61 +896,6 @@ int ConversionsTest::DoTest(Type outType, Type inType, SaturationMode sat, log_info("done.\n"); - if (gTimeResults) - { - // Kick off tests for the various vector lengths - for (vectorSize = gMinVectorSize; vectorSize < gMaxVectorSize; - vectorSize++) - { - size_t workItemCount = blockCount / vectorSizes[vectorSize]; - if (vectorSizes[vectorSize] * gTypeSizes[outType] < 4) - workItemCount /= - 4 / (vectorSizes[vectorSize] * gTypeSizes[outType]); - - double sum = 0.0; - double bestTime = INFINITY; - cl_uint k; - for (k = 0; k < PERF_LOOP_COUNT; k++) - { - uint64_t startTime = conv_test::GetTime(); - if ((error = conv_test::RunKernel( - writeInputBufferInfo.calcInfo[vectorSize]->kernel, - gInBuffer, gOutBuffers[vectorSize], workItemCount))) - { - gFailCount++; - return error; - } - - // Make sure OpenCL is done - if ((error = clFinish(gQueue))) - { - vlog_error("Error %d at clFinish\n", error); - return error; - } - - uint64_t endTime = conv_test::GetTime(); - double time = SubtractTime(endTime, startTime); - sum += time; - if (time < bestTime) bestTime = time; - } - - if (gReportAverageTimes) bestTime = sum / PERF_LOOP_COUNT; - double clocksPerOp = bestTime * (double)gDeviceFrequency - * gComputeDevices * gSimdSize * 1e6 - / (workItemCount * vectorSizes[vectorSize]); - if (0 == vectorSize) - vlog_perf(clocksPerOp, LOWER_IS_BETTER, "clocks / element", - "implicit convert %s -> %s", gTypeNames[inType], - gTypeNames[outType]); - else - vlog_perf(clocksPerOp, LOWER_IS_BETTER, "clocks / element", - "convert_%s%s%s%s( %s%s )", gTypeNames[outType], - sizeNames[vectorSize], gSaturationNames[sat], - gRoundingModeNames[round], gTypeNames[inType], - sizeNames[vectorSize]); - } - } - if (gWimpyMode) vlog("\tWimp pass"); else @@ -978,33 +915,6 @@ int ConversionsTest::DoTest(Type outType, Type inType, SaturationMode sat, void memset_pattern4(void *dest, const void *src_pattern, size_t bytes); #endif -#if defined(_MSC_VER) -/* function is defined in "compat.h" */ -#else -double SubtractTime(uint64_t endTime, uint64_t startTime) -{ - uint64_t diff = endTime - startTime; - static double conversion = 0.0; - - if (0.0 == conversion) - { -#if defined(__APPLE__) - mach_timebase_info_data_t info = { 0, 0 }; - kern_return_t err = mach_timebase_info(&info); - if (0 == err) - conversion = 1e-9 * (double)info.numer / (double)info.denom; -#else - // This function consumes output from GetTime() above, and converts the - // time to secionds. -#warning need accurate ticks to seconds conversion factor here. Times are invalid. -#endif - } - - // strictly speaking we should also be subtracting out timer latency here - return conversion * (double)diff; -} -#endif - void MapResultValuesComplete(const std::unique_ptr &ptr); void CL_CALLBACK CalcReferenceValuesComplete(cl_event e, cl_int status, @@ -1352,20 +1262,6 @@ cl_int PrepareReference(cl_uint job_id, cl_uint thread_id, void *p) return CL_SUCCESS; } -uint64_t GetTime(void) -{ -#if defined(__APPLE__) - return mach_absolute_time(); -#elif defined(_MSC_VER) - return ReadTime(); -#else - // mach_absolute_time is a high precision timer with precision < 1 - // microsecond. -#warning need accurate clock here. Times are invalid. - return 0; -#endif -} - // Note: not called reentrantly void WriteInputBufferComplete(void *data) { diff --git a/test_conformance/conversions/basic_test_conversions.h b/test_conformance/conversions/basic_test_conversions.h index c7b24b70..56232374 100644 --- a/test_conformance/conversions/basic_test_conversions.h +++ b/test_conformance/conversions/basic_test_conversions.h @@ -86,8 +86,6 @@ extern int gSkipTesting; extern int gMinVectorSize; extern int gMaxVectorSize; extern int gForceFTZ; -extern int gTimeResults; -extern int gReportAverageTimes; extern int gStartTestNumber; extern int gEndTestNumber; extern int gIsRTZ; diff --git a/test_conformance/conversions/test_conversions.cpp b/test_conformance/conversions/test_conversions.cpp index 82cb5c2d..1712e099 100644 --- a/test_conformance/conversions/test_conversions.cpp +++ b/test_conformance/conversions/test_conversions.cpp @@ -226,8 +226,6 @@ static int ParseArgs(int argc, const char **argv) gForceFTZ ^= 1; gForceHalfFTZ ^= 1; break; - case 't': gTimeResults ^= 1; break; - case 'a': gReportAverageTimes ^= 1; break; case '1': if (arg[1] == '6') { diff --git a/test_conformance/extensions/CMakeLists.txt b/test_conformance/extensions/CMakeLists.txt index d064e8a9..aa57990b 100644 --- a/test_conformance/extensions/CMakeLists.txt +++ b/test_conformance/extensions/CMakeLists.txt @@ -8,6 +8,7 @@ add_subdirectory( cl_khr_dx9_media_sharing ) add_subdirectory( cl_khr_external_memory_dma_buf ) add_subdirectory( cl_khr_semaphore ) add_subdirectory( cl_khr_kernel_clock ) +add_subdirectory( cl_ext_buffer_device_address ) if(VULKAN_IS_SUPPORTED) add_subdirectory( cl_khr_external_semaphore ) endif() diff --git a/test_conformance/extensions/cl_ext_buffer_device_address/CMakeLists.txt b/test_conformance/extensions/cl_ext_buffer_device_address/CMakeLists.txt new file mode 100644 index 00000000..c4478693 --- /dev/null +++ b/test_conformance/extensions/cl_ext_buffer_device_address/CMakeLists.txt @@ -0,0 +1,7 @@ +set(MODULE_NAME CL_EXT_BUFFER_DEVICE_ADDRESS) + +set(${MODULE_NAME}_SOURCES + main.cpp buffer_device_address.cpp +) + +include(../../CMakeCommon.txt) diff --git a/test_conformance/extensions/cl_ext_buffer_device_address/buffer_device_address.cpp b/test_conformance/extensions/cl_ext_buffer_device_address/buffer_device_address.cpp new file mode 100644 index 00000000..97872613 --- /dev/null +++ b/test_conformance/extensions/cl_ext_buffer_device_address/buffer_device_address.cpp @@ -0,0 +1,437 @@ +// 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 "harness/typeWrappers.h" +#include + +#define BUF_SIZE 1024 +#define BUF_SIZE_STR "1024" + +namespace { + +static const char *program_source = + R"raw( + // A kernel that gets the device-seen address of the buffer. + __kernel void get_addr (__global int *buffer, + __global ulong* addr) { + for (int i = 0; i < BUF_SIZE; ++i) + buffer[i] += 1; + *addr = (ulong)buffer; + } + + // A kernel that accesses another buffer indirectly. + __kernel void indirect_access (__global long* in_addr, + __global int* out) { + *out = **(int __global* __global*)in_addr; + } + + // A kernel that gets passed a pointer to a middle of a buffer, + // with the data _before_ the passed pointer. Tests the property + // of sub-buffers to synchronize the whole parent buffer when + // using the CL_MEM_BUFFER_DEVICE_ADDRESS flag. + __kernel void ptr_arith (__global int* in_addr, + __global int* out) { + *out = *(in_addr - 2); + } + )raw"; + +class BufferDeviceAddressTest { + +public: + BufferDeviceAddressTest(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_mem_properties address_type) + : device(device), context(context), queue(queue), + address_type(address_type) + {} + + bool Skip() + { + cl_int error = 0; + + cl_mem_properties buf_props[] = { address_type, CL_TRUE, 0 }; + clMemWrapper TempBuffer = clCreateBufferWithProperties( + context, buf_props, CL_MEM_READ_WRITE, + (size_t)BUF_SIZE * sizeof(cl_int), nullptr, &error); + return (error != CL_SUCCESS); + } + + cl_int RunTest() + { + cl_int error; + + clProgramWrapper program; + clKernelWrapper get_addr_kernel, indirect_access_kernel, + ptr_arith_kernel; + clMemWrapper dev_addr_buffer, buffer_long, buffer_int, + dev_addr_no_host_buffer; + + error = create_single_kernel_helper(context, &program, &get_addr_kernel, + 1, &program_source, "get_addr", + "-DBUF_SIZE=" BUF_SIZE_STR); + test_error(error, "Failed to create program with source\n"); + + indirect_access_kernel = + clCreateKernel(program, "indirect_access", &error); + test_error(error, "Failed to create kernel indirect_access\n"); + + ptr_arith_kernel = clCreateKernel(program, "ptr_arith", &error); + test_error(error, "Failed to create kernel ptr_arith\n"); + + buffer_long = clCreateBuffer(context, CL_MEM_READ_WRITE, + sizeof(cl_ulong), nullptr, &error); + test_error(error, "clCreateBuffer failed\n"); + + buffer_int = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), + nullptr, &error); + test_error(error, "clCreateBuffer failed\n"); + + // Test a buffer with hostptr copied data + cl_mem_properties buf_props[] = { address_type, CL_TRUE, 0 }; + dev_addr_buffer = clCreateBufferWithProperties( + context, buf_props, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, + sizeof(cl_int) * BUF_SIZE, BufferHost, &error); + test_error(error, "clCreateBuffer with device address 1 failed\n"); + + if (test_buffer(dev_addr_buffer, buffer_long, get_addr_kernel) + != TEST_PASS) + test_fail("test_buffer_host failed\n"); + + // Test a buffer which doesn't have any hostptr associated with it. + dev_addr_no_host_buffer = clCreateBufferWithProperties( + context, buf_props, CL_MEM_READ_WRITE, sizeof(cl_int) * BUF_SIZE, + nullptr, &error); + test_error(error, "clCreateBuffer with device address 2 failed\n"); + + if (test_buffer(dev_addr_no_host_buffer, buffer_long, get_addr_kernel) + != TEST_PASS) + test_fail("test_buffer_no_host failed\n"); + + // Test a buffer passed indirectly + if (test_indirect_buffer(dev_addr_buffer, buffer_long, buffer_int, + indirect_access_kernel) + != TEST_PASS) + test_fail("test_indirect_buffer failed\n"); + + if (test_set_kernel_arg(dev_addr_buffer, buffer_int, ptr_arith_kernel) + != TEST_PASS) + test_fail("test_set_kernel_arg failed\n"); + + if (test_svm_buffer() == TEST_FAIL) + test_fail("test_svm_buffer failed\n"); + + return TEST_PASS; + } + +private: + int BufferHost[BUF_SIZE]; + size_t global_size_one[3] = { 1, 1, 1 }; + cl_device_id device; + cl_context context; + cl_command_queue queue; + cl_mem_properties address_type; + + int check_device_address_from_api(cl_mem buf, + cl_mem_device_address_ext &Addr) + { + Addr = 0; + cl_int error = clGetMemObjectInfo(buf, CL_MEM_DEVICE_ADDRESS_EXT, + sizeof(Addr), &Addr, NULL); + test_error(error, + "clGetMemObjectInfo(CL_MEM_DEVICE_ADDRESS_EXT) failed\n"); + if (Addr == 0) + { + print_error(error, + "clGetMemObjectInfo(CL_MEM_DEVICE_ADDRESS_EXT) " + "returned 0 as address\n"); + return CL_INVALID_VALUE; + } + return CL_SUCCESS; + } + + int test_svm_buffer() + { + clSVMWrapper svm_buffer; + clMemWrapper buffer; + cl_int error = 0; + + cl_device_svm_capabilities svm_caps = 0; + error = clGetDeviceInfo(device, CL_DEVICE_SVM_CAPABILITIES, + sizeof(svm_caps), &svm_caps, NULL); + if (error != CL_SUCCESS) + { + print_missing_feature(error, + "Unable to get SVM capabilities, " + "skipping"); + return TEST_SKIP; + } + if ((svm_caps & CL_DEVICE_SVM_COARSE_GRAIN_BUFFER) == 0) + { + print_missing_feature(error, + "Device doesn't support " + "CL_DEVICE_SVM_COARSE_" + "GRAIN_BUFFER, skipping"); + return TEST_SKIP; + } + + svm_buffer = + clSVMWrapper(context, sizeof(cl_int) * BUF_SIZE, + CL_DEVICE_SVM_COARSE_GRAIN_BUFFER | CL_MEM_READ_WRITE); + if (svm_buffer() == nullptr) + { + test_error(CL_OUT_OF_RESOURCES, "SVM allocation failed"); + } + + cl_mem_properties buf_props[] = { address_type, CL_TRUE, 0 }; + buffer = clCreateBufferWithProperties( + context, buf_props, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, + sizeof(cl_int) * BUF_SIZE, svm_buffer(), &error); + test_error(error, "clCreateBuffer with device address 1 failed\n"); + + cl_mem_device_address_ext Addr = 0; + error = clGetMemObjectInfo(buffer, CL_MEM_DEVICE_ADDRESS_EXT, + sizeof(Addr), &Addr, NULL); + test_error(error, + "clGetMemObjectInfo(CL_MEM_DEVICE_ADDRESS_EXT) failed\n"); + + if ((void *)Addr != svm_buffer()) + { + test_fail("clGetMemObjectInfo(CL_MEM_DEVICE_ADDRESS_EXT) " + "returned different address than clSVMAlloc\n"); + } + return TEST_PASS; + } + + + int test_buffer(clMemWrapper &dev_addr_buffer, clMemWrapper &plain_buffer, + clKernelWrapper &get_addr_kernel) + { + cl_int error = 0; + cl_ulong DeviceAddrFromKernel = 0; + cl_mem_device_address_ext DeviceAddrFromAPI = 0; + + for (int i = 0; i < BUF_SIZE; ++i) + { + BufferHost[i] = i; + } + + error = + check_device_address_from_api(dev_addr_buffer, DeviceAddrFromAPI); + test_error_fail(error, + "device address buffer does not have device address"); + + error = clEnqueueWriteBuffer(queue, dev_addr_buffer, + CL_FALSE, // block + 0, BUF_SIZE * sizeof(cl_int), BufferHost, + 0, NULL, NULL); + test_error_fail(error, + "clEnqueueWriteBuffer of dev_addr_buffer failed\n"); + + error = clSetKernelArg(get_addr_kernel, 0, sizeof(cl_mem), + &dev_addr_buffer); + test_error_fail(error, "clSetKernelArg 0 failed\n"); + error = + clSetKernelArg(get_addr_kernel, 1, sizeof(cl_mem), &plain_buffer); + test_error_fail(error, "clSetKernelArg 1 failed\n"); + + error = clEnqueueNDRangeKernel(queue, get_addr_kernel, 1, NULL, + global_size_one, NULL, 0, NULL, NULL); + test_error_fail(error, "clNDRangeKernel failed\n"); + + error = clEnqueueReadBuffer(queue, dev_addr_buffer, CL_FALSE, 0, + sizeof(cl_int) * BUF_SIZE, BufferHost, 0, + NULL, NULL); + test_error_fail(error, + "clEnqueueReadBuffer of dev_addr_buffer failed\n"); + + error = clEnqueueReadBuffer(queue, plain_buffer, CL_FALSE, 0, + sizeof(cl_ulong), &DeviceAddrFromKernel, 0, + NULL, NULL); + test_error_fail(error, "clEnqueueReadBuffer of buffer failed\n"); + + error = clFinish(queue); + test_error_fail(error, "clFinish failed\n"); + + for (int i = 0; i < BUF_SIZE; ++i) + { + if (BufferHost[i] != (i + 1)) + { + test_fail("BufferHost[%i] expected " + "to be: %i, but is: %i\n", + i, i + 1, BufferHost[i]); + } + } + + if (DeviceAddrFromAPI != DeviceAddrFromKernel) + { + test_fail("DeviceAddrFromAPI(%" PRIu64 + ") != DeviceAddrFromKernel(%" PRIu64 ")\n", + (uint64_t)DeviceAddrFromAPI, + (uint64_t)DeviceAddrFromKernel); + } + return TEST_PASS; + } + + int test_indirect_buffer(clMemWrapper &dev_addr_buffer, + clMemWrapper &buffer_in_long, + clMemWrapper &buffer_out_int, + clKernelWrapper &ind_access_kernel) + { + cl_int error = 0; + cl_mem_device_address_ext DeviceAddrFromAPI = 0; + + int DataIn = 0x12348765; + int DataOut = -1; + + // A devaddr buffer with the payload data. + error = clEnqueueWriteBuffer(queue, dev_addr_buffer, + CL_TRUE, // block + 0, sizeof(cl_int), &DataIn, 0, NULL, NULL); + test_error_fail(error, + "clEnqueueWriteBuffer of dev_addr_buffer failed\n"); + + error = + check_device_address_from_api(dev_addr_buffer, DeviceAddrFromAPI); + test_error_fail(error, + "device address buffer does not have device address") + + // A basic buffer used to pass the other buffer's address. + error = clEnqueueWriteBuffer(queue, buffer_in_long, + CL_TRUE, // block + 0, sizeof(cl_long), &DeviceAddrFromAPI, + 0, NULL, NULL); + test_error_fail(error, + "clEnqueueWriteBuffer of dev_addr_buffer failed\n"); + + error = clSetKernelArg(ind_access_kernel, 0, sizeof(cl_mem), + &buffer_in_long); + test_error_fail(error, "clSetKernelArg 0 failed\n"); + error = clSetKernelArg(ind_access_kernel, 1, sizeof(cl_mem), + &buffer_out_int); + test_error_fail(error, "clSetKernelArg 1 failed\n"); + + error = clSetKernelExecInfo(ind_access_kernel, + CL_KERNEL_EXEC_INFO_DEVICE_PTRS_EXT, + sizeof(void *), &DeviceAddrFromAPI); + test_error_fail(error, + "Setting indirect access for " + "device ptrs failed!\n"); + + error = clEnqueueNDRangeKernel(queue, ind_access_kernel, 1, NULL, + global_size_one, NULL, 0, NULL, NULL); + test_error_fail(error, "clNDRangeKernel failed\n"); + + error = clEnqueueReadBuffer(queue, buffer_out_int, CL_FALSE, 0, + sizeof(cl_int), &DataOut, 0, NULL, NULL); + test_error_fail(error, "clEnqueueReadBuffer of buffer failed\n"); + + error = clFinish(queue); + test_error_fail(error, "clFinish failed\n"); + + for (int i = 0; i < BUF_SIZE; ++i) + { + if (BufferHost[i] != i + 1) + { + test_fail("PinnedBufferHost[%i] expected " + "to be: %i, but is: %i\n", + i, i + 1, BufferHost[i]); + } + } + + if (DataIn != DataOut) + { + test_fail("Passing data via indirect buffers failed. " + "Got: %i expected: %i\n", + DataOut, DataIn); + } + return TEST_PASS; + } + + int test_set_kernel_arg(clMemWrapper &dev_addr_buffer, + clMemWrapper &buffer_out_int, + clKernelWrapper &ptr_arith_kernel) + { + cl_int error = 0; + cl_mem_device_address_ext DeviceAddrFromAPI = 0; + int DataOut = -1; + int DataIn = 0x12348765; + + clSetKernelArgDevicePointerEXT_fn clSetKernelArgDevicePointer = + (clSetKernelArgDevicePointerEXT_fn) + clGetExtensionFunctionAddressForPlatform( + getPlatformFromDevice(device), + "clSetKernelArgDevicePointerEXT"); + if (clSetKernelArgDevicePointer == nullptr) + test_error_fail( + error, "Cannot get address of clSetKernelArgDevicePointerEXT"); + + error = clEnqueueWriteBuffer(queue, dev_addr_buffer, + CL_FALSE, // block + 0, sizeof(cl_int), &DataIn, 0, NULL, NULL); + test_error_fail(error, + "clEnqueueWriteBuffer of dev_addr_buffer failed\n"); + + error = + check_device_address_from_api(dev_addr_buffer, DeviceAddrFromAPI); + test_error_fail(error, "dev_addr_buffer does not have device address"); + + cl_mem_device_address_ext DeviceAddrFromAPIP2 = + (cl_mem_device_address_ext)(((cl_uint *)DeviceAddrFromAPI) + 2); + error = clSetKernelArgDevicePointer(ptr_arith_kernel, 0, + DeviceAddrFromAPIP2); + test_error_fail(error, "clSetKernelArgDevicePointer failed\n"); + error = clSetKernelArg(ptr_arith_kernel, 1, sizeof(cl_mem), + &buffer_out_int); + test_error_fail(error, "clSetKernelArg 1 failed\n"); + + error = clEnqueueNDRangeKernel(queue, ptr_arith_kernel, 1, NULL, + global_size_one, NULL, 0, NULL, NULL); + test_error_fail(error, "clNDRangeKernel failed\n"); + + error = clEnqueueReadBuffer(queue, buffer_out_int, CL_FALSE, 0, + sizeof(cl_int), &DataOut, 0, NULL, NULL); + test_error_fail(error, "clEnqueueReadBuffer of buffer failed\n"); + + error = clFinish(queue); + test_error_fail(error, "clFinish failed\n"); + + if (DataIn != DataOut) + { + test_fail("Negative offsetting from passed in pointer failed: " + "got: %i expected: %i", + DataOut, DataIn); + } + return TEST_PASS; + } +}; + +} + +REGISTER_TEST(private_address) +{ + BufferDeviceAddressTest test_fixture = BufferDeviceAddressTest( + device, context, queue, CL_MEM_DEVICE_PRIVATE_ADDRESS_EXT); + + if (test_fixture.Skip()) + { + log_info("Test fixture skip\n"); + return TEST_SKIPPED_ITSELF; + } + + cl_int error = test_fixture.RunTest(); + test_error_ret(error, "Test Failed", TEST_FAIL); + + return TEST_PASS; +} diff --git a/test_conformance/extensions/cl_ext_buffer_device_address/main.cpp b/test_conformance/extensions/cl_ext_buffer_device_address/main.cpp new file mode 100644 index 00000000..31d01fa9 --- /dev/null +++ b/test_conformance/extensions/cl_ext_buffer_device_address/main.cpp @@ -0,0 +1,58 @@ +// 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 "harness/testHarness.h" +#include "harness/deviceInfo.h" + +test_status InitCL(cl_device_id device) +{ + auto version = get_device_cl_version(device); + auto expected_min_version = Version(3, 0); + + if (version < expected_min_version) + { + version_expected_info("Test", "OpenCL", + expected_min_version.to_string().c_str(), + version.to_string().c_str()); + return TEST_SKIP; + } + + if (!is_extension_available(device, "cl_ext_buffer_device_address")) + { + log_info("The device does not support the " + "cl_ext_buffer_device_address extension.\n"); + return TEST_SKIPPED_ITSELF; + } + + cl_version ext_version = + get_extension_version(device, "cl_ext_buffer_device_address"); + if (ext_version != CL_MAKE_VERSION(1, 0, 2)) + { + log_info("The test is written against cl_ext_buffer_device_address " + "extension version 1.0.2, device supports version: %u.%u.%u\n", + CL_VERSION_MAJOR(ext_version), CL_VERSION_MINOR(ext_version), + CL_VERSION_PATCH(ext_version)); + return TEST_SKIPPED_ITSELF; + } + + return TEST_PASS; +} + +int main(int argc, const char *argv[]) +{ + return runTestHarnessWithCheck( + argc, argv, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, InitCL); +} diff --git a/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ext.cpp b/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ext.cpp index 1d5252cb..aee287fd 100644 --- a/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ext.cpp +++ b/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ext.cpp @@ -13,8 +13,9 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" +#include +#include "harness/typeWrappers.h" int test_cxx_for_opencl(cl_device_id device, cl_context context, cl_command_queue queue) @@ -90,8 +91,7 @@ int test_cxx_for_opencl(cl_device_id device, cl_context context, return TEST_PASS; } -int test_cxx_for_opencl_ext(cl_device_id device, cl_context context, - cl_command_queue queue, int) +REGISTER_TEST_VERSION(cxx_for_opencl_ext, Version(2, 0)) { if (!is_extension_available(device, "cl_ext_cxx_for_opencl")) { diff --git a/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ver.cpp b/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ver.cpp index 03760814..ed2cebf3 100644 --- a/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ver.cpp +++ b/test_conformance/extensions/cl_ext_cxx_for_opencl/cxx_for_opencl_ver.cpp @@ -13,8 +13,9 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" +#include +#include "harness/typeWrappers.h" int test_cxx_for_opencl_version(cl_device_id device, cl_context context, cl_command_queue queue) @@ -88,8 +89,7 @@ int test_cxx_for_opencl_version(cl_device_id device, cl_context context, return TEST_PASS; } -int test_cxx_for_opencl_ver(cl_device_id device, cl_context context, - cl_command_queue queue, int) +REGISTER_TEST_VERSION(cxx_for_opencl_ver, Version(2, 0)) { if (!is_extension_available(device, "cl_ext_cxx_for_opencl")) { diff --git a/test_conformance/extensions/cl_ext_cxx_for_opencl/main.cpp b/test_conformance/extensions/cl_ext_cxx_for_opencl/main.cpp index 5e8c14af..9a7b75b9 100644 --- a/test_conformance/extensions/cl_ext_cxx_for_opencl/main.cpp +++ b/test_conformance/extensions/cl_ext_cxx_for_opencl/main.cpp @@ -14,15 +14,11 @@ // limitations under the License. // -#include "procs.h" - -test_definition test_list[] = { - ADD_TEST_VERSION(cxx_for_opencl_ext, Version(2, 0)), - ADD_TEST_VERSION(cxx_for_opencl_ver, Version(2, 0)) -}; +#include "harness/testHarness.h" int main(int argc, const char *argv[]) { - return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list, - false, 0, nullptr); + return runTestHarnessWithCheck( + argc, argv, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, nullptr); } diff --git a/test_conformance/extensions/cl_ext_cxx_for_opencl/procs.h b/test_conformance/extensions/cl_ext_cxx_for_opencl/procs.h deleted file mode 100644 index 5665e012..00000000 --- a/test_conformance/extensions/cl_ext_cxx_for_opencl/procs.h +++ /dev/null @@ -1,26 +0,0 @@ -// -// Copyright (c) 2021 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. -// -#ifndef _procs_h -#define _procs_h - -#include "harness/typeWrappers.h" - -extern int test_cxx_for_opencl_ext(cl_device_id device, cl_context context, - cl_command_queue queue, int); -extern int test_cxx_for_opencl_ver(cl_device_id device, cl_context context, - cl_command_queue queue, int); - -#endif /*_procs_h*/ diff --git a/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt b/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt index 560938a2..a4983da0 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt +++ b/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt @@ -3,6 +3,7 @@ set(MODULE_NAME CL_KHR_COMMAND_BUFFER) set(${MODULE_NAME}_SOURCES main.cpp basic_command_buffer.cpp + basic_command_buffer_tests.cpp svm_command_basic.cpp command_buffer_printf.cpp command_buffer_get_command_buffer_info.cpp diff --git a/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.cpp b/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.cpp index c17b65d6..43926b84 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include #include @@ -186,324 +185,253 @@ cl_int BasicCommandBufferTest::SetUp(int elements) return CL_SUCCESS; } -namespace { - -// Test that the CL_COMMAND_BUFFER_FLAGS_KHR bitfield is parsed correctly when -// multiple flags are set. -struct MultiFlagCreationTest : public BasicCommandBufferTest +cl_int MultiFlagCreationTest::Run() { - using BasicCommandBufferTest::BasicCommandBufferTest; + cl_command_buffer_properties_khr flags = 0; + cl_int error = CL_SUCCESS; - cl_int Run() override + // First try to find multiple flags that are supported by the driver and + // device. + if (simultaneous_use_support) { - cl_command_buffer_properties_khr flags = 0; - cl_int error = CL_SUCCESS; - - // First try to find multiple flags that are supported by the driver and - // device. - if (simultaneous_use_support) - { - flags |= CL_COMMAND_BUFFER_SIMULTANEOUS_USE_KHR; - } - - if (is_extension_available( - device, CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_NAME)) - { - flags |= CL_COMMAND_BUFFER_DEVICE_SIDE_SYNC_KHR; - } - - if (is_extension_available( - device, CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME)) - { - flags |= CL_COMMAND_BUFFER_MUTABLE_KHR; - } - - cl_command_buffer_properties_khr props[] = { - CL_COMMAND_BUFFER_FLAGS_KHR, flags, 0 - }; - - command_buffer = clCreateCommandBufferKHR(1, &queue, props, &error); - test_error(error, "clCreateCommandBufferKHR failed"); - - return CL_SUCCESS; + flags |= CL_COMMAND_BUFFER_SIMULTANEOUS_USE_KHR; } + + if (is_extension_available( + device, CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_NAME)) + { + flags |= CL_COMMAND_BUFFER_DEVICE_SIDE_SYNC_KHR; + } + + if (is_extension_available( + device, CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME)) + { + flags |= CL_COMMAND_BUFFER_MUTABLE_KHR; + } + + cl_command_buffer_properties_khr props[] = { CL_COMMAND_BUFFER_FLAGS_KHR, + flags, 0 }; + + command_buffer = clCreateCommandBufferKHR(1, &queue, props, &error); + test_error(error, "clCreateCommandBufferKHR failed"); + + return CL_SUCCESS; }; -// Test enqueuing a command-buffer containing a single NDRange command once -struct BasicEnqueueTest : public BasicCommandBufferTest +cl_int BasicEnqueueTest::Run() { - using BasicCommandBufferTest::BasicCommandBufferTest; - cl_int Run() override + cl_int error = clCommandNDRangeKernelKHR( + command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements, + nullptr, 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandNDRangeKernelKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + const cl_int pattern = 42; + error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0, + data_size(), 0, nullptr, nullptr); + test_error(error, "clEnqueueFillBuffer failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data_1(num_elements); + error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), + output_data_1.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < num_elements; i++) { - cl_int error = clCommandNDRangeKernelKHR( + CHECK_VERIFICATION_ERROR(pattern, output_data_1[i], i); + } + + const cl_int new_pattern = 12; + error = clEnqueueFillBuffer(queue, in_mem, &new_pattern, sizeof(cl_int), 0, + data_size(), 0, nullptr, nullptr); + test_error(error, "clEnqueueFillBuffer failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data_2(num_elements); + error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), + output_data_2.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < num_elements; i++) + { + CHECK_VERIFICATION_ERROR(new_pattern, output_data_2[i], i); + } + + return CL_SUCCESS; +}; + +cl_int MixedCommandsTest::Run() +{ + cl_int error; + const size_t iterations = 4; + clMemWrapper result_mem = + clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int) * iterations, + nullptr, &error); + test_error(error, "clCreateBuffer failed"); + + const cl_int pattern_base = 42; + for (size_t i = 0; i < iterations; i++) + { + const cl_int pattern = pattern_base + i; + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, nullptr, in_mem, &pattern, sizeof(cl_int), + 0, data_size(), 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandFillBufferKHR failed"); + + error = clCommandNDRangeKernelKHR( command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements, nullptr, 0, nullptr, nullptr, nullptr); test_error(error, "clCommandNDRangeKernelKHR failed"); - error = clFinalizeCommandBufferKHR(command_buffer); - test_error(error, "clFinalizeCommandBufferKHR failed"); - - const cl_int pattern = 42; - error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0, - data_size(), 0, nullptr, nullptr); - test_error(error, "clEnqueueFillBuffer failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - std::vector output_data_1(num_elements); - error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), - output_data_1.data(), 0, nullptr, nullptr); - test_error(error, "clEnqueueReadBuffer failed"); - - for (size_t i = 0; i < num_elements; i++) - { - CHECK_VERIFICATION_ERROR(pattern, output_data_1[i], i); - } - - const cl_int new_pattern = 12; - error = clEnqueueFillBuffer(queue, in_mem, &new_pattern, sizeof(cl_int), - 0, data_size(), 0, nullptr, nullptr); - test_error(error, "clEnqueueFillBuffer failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - std::vector output_data_2(num_elements); - error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), - output_data_2.data(), 0, nullptr, nullptr); - test_error(error, "clEnqueueReadBuffer failed"); - - for (size_t i = 0; i < num_elements; i++) - { - CHECK_VERIFICATION_ERROR(new_pattern, output_data_2[i], i); - } - - return CL_SUCCESS; + const size_t result_offset = i * sizeof(cl_int); + error = clCommandCopyBufferKHR( + command_buffer, nullptr, nullptr, out_mem, result_mem, 0, + result_offset, sizeof(cl_int), 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandCopyBufferKHR failed"); } -}; -// Test enqueuing a command-buffer containing multiple command, including -// operations other than NDRange kernel execution. -struct MixedCommandsTest : public BasicCommandBufferTest -{ - using BasicCommandBufferTest::BasicCommandBufferTest; + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); - cl_int Run() override + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector result_data(num_elements); + error = clEnqueueReadBuffer(queue, result_mem, CL_TRUE, 0, + iterations * sizeof(cl_int), result_data.data(), + 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < iterations; i++) { - cl_int error; - const size_t iterations = 4; - clMemWrapper result_mem = - clCreateBuffer(context, CL_MEM_READ_WRITE, - sizeof(cl_int) * iterations, nullptr, &error); - test_error(error, "clCreateBuffer failed"); - - const cl_int pattern_base = 42; - for (size_t i = 0; i < iterations; i++) - { - const cl_int pattern = pattern_base + i; - cl_int error = clCommandFillBufferKHR( - command_buffer, nullptr, nullptr, in_mem, &pattern, - sizeof(cl_int), 0, data_size(), 0, nullptr, nullptr, nullptr); - test_error(error, "clCommandFillBufferKHR failed"); - - error = clCommandNDRangeKernelKHR( - command_buffer, nullptr, nullptr, kernel, 1, nullptr, - &num_elements, nullptr, 0, nullptr, nullptr, nullptr); - test_error(error, "clCommandNDRangeKernelKHR failed"); - - const size_t result_offset = i * sizeof(cl_int); - error = clCommandCopyBufferKHR( - command_buffer, nullptr, nullptr, out_mem, result_mem, 0, - result_offset, sizeof(cl_int), 0, nullptr, nullptr, nullptr); - test_error(error, "clCommandCopyBufferKHR failed"); - } - - error = clFinalizeCommandBufferKHR(command_buffer); - test_error(error, "clFinalizeCommandBufferKHR failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - std::vector result_data(num_elements); - error = clEnqueueReadBuffer(queue, result_mem, CL_TRUE, 0, - iterations * sizeof(cl_int), - result_data.data(), 0, nullptr, nullptr); - test_error(error, "clEnqueueReadBuffer failed"); - - for (size_t i = 0; i < iterations; i++) - { - const cl_int ref = pattern_base + i; - CHECK_VERIFICATION_ERROR(ref, result_data[i], i); - } - - return CL_SUCCESS; - } -}; - -// Test flushing the command-queue between command-buffer enqueues -struct ExplicitFlushTest : public BasicCommandBufferTest -{ - using BasicCommandBufferTest::BasicCommandBufferTest; - - cl_int Run() override - { - cl_int error = clCommandNDRangeKernelKHR( - command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements, - nullptr, 0, nullptr, nullptr, nullptr); - test_error(error, "clCommandNDRangeKernelKHR failed"); - - error = clFinalizeCommandBufferKHR(command_buffer); - test_error(error, "clFinalizeCommandBufferKHR failed"); - - const cl_int pattern_A = 42; - error = clEnqueueFillBuffer(queue, in_mem, &pattern_A, sizeof(cl_int), - 0, data_size(), 0, nullptr, nullptr); - test_error(error, "clEnqueueFillBuffer failed"); - - error = clFlush(queue); - test_error(error, "clFlush failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - std::vector output_data_A(num_elements); - error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(), - output_data_A.data(), 0, nullptr, nullptr); - test_error(error, "clEnqueueReadBuffer failed"); - - const cl_int pattern_B = 0xA; - error = clEnqueueFillBuffer(queue, in_mem, &pattern_B, sizeof(cl_int), - 0, data_size(), 0, nullptr, nullptr); - test_error(error, "clEnqueueFillBuffer failed"); - - error = clFlush(queue); - test_error(error, "clFlush failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - error = clFlush(queue); - test_error(error, "clFlush failed"); - - std::vector output_data_B(num_elements); - error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(), - output_data_B.data(), 0, nullptr, nullptr); - test_error(error, "clEnqueueReadBuffer failed"); - - error = clFinish(queue); - test_error(error, "clFinish failed"); - - for (size_t i = 0; i < num_elements; i++) - { - CHECK_VERIFICATION_ERROR(pattern_A, output_data_A[i], i); - - CHECK_VERIFICATION_ERROR(pattern_B, output_data_B[i], i); - } - return CL_SUCCESS; + const cl_int ref = pattern_base + i; + CHECK_VERIFICATION_ERROR(ref, result_data[i], i); } - bool Skip() override - { - return BasicCommandBufferTest::Skip() || !simultaneous_use_support; - } -}; - -// Test enqueueing a command-buffer twice separated by another enqueue operation -struct InterleavedEnqueueTest : public BasicCommandBufferTest -{ - using BasicCommandBufferTest::BasicCommandBufferTest; - - cl_int Run() override - { - cl_int error = clCommandNDRangeKernelKHR( - command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements, - nullptr, 0, nullptr, nullptr, nullptr); - test_error(error, "clCommandNDRangeKernelKHR failed"); - - error = clFinalizeCommandBufferKHR(command_buffer); - test_error(error, "clFinalizeCommandBufferKHR failed"); - - cl_int pattern = 42; - error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0, - data_size(), 0, nullptr, nullptr); - test_error(error, "clEnqueueFillBuffer failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - pattern = 0xABCD; - error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0, - data_size(), 0, nullptr, nullptr); - test_error(error, "clEnqueueFillBuffer failed"); - - error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, - nullptr, nullptr); - test_error(error, "clEnqueueCommandBufferKHR failed"); - - error = clEnqueueCopyBuffer(queue, in_mem, out_mem, 0, 0, data_size(), - 0, nullptr, nullptr); - test_error(error, "clEnqueueCopyBuffer failed"); - - std::vector output_data(num_elements); - error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), - output_data.data(), 0, nullptr, nullptr); - test_error(error, "clEnqueueReadBuffer failed"); - - for (size_t i = 0; i < num_elements; i++) - { - CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); - } - - return CL_SUCCESS; - } - - bool Skip() override - { - return BasicCommandBufferTest::Skip() || !simultaneous_use_support; - } -}; - -} // anonymous namespace - -int test_multi_flag_creation(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) -{ - return MakeAndRunTest(device, context, queue, - num_elements); + return CL_SUCCESS; } -int test_single_ndrange(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +cl_int ExplicitFlushTest::Run() { - return MakeAndRunTest(device, context, queue, - num_elements); + cl_int error = clCommandNDRangeKernelKHR( + command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements, + nullptr, 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandNDRangeKernelKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + const cl_int pattern_A = 42; + error = clEnqueueFillBuffer(queue, in_mem, &pattern_A, sizeof(cl_int), 0, + data_size(), 0, nullptr, nullptr); + test_error(error, "clEnqueueFillBuffer failed"); + + error = clFlush(queue); + test_error(error, "clFlush failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data_A(num_elements); + error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(), + output_data_A.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + const cl_int pattern_B = 0xA; + error = clEnqueueFillBuffer(queue, in_mem, &pattern_B, sizeof(cl_int), 0, + data_size(), 0, nullptr, nullptr); + test_error(error, "clEnqueueFillBuffer failed"); + + error = clFlush(queue); + test_error(error, "clFlush failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + error = clFlush(queue); + test_error(error, "clFlush failed"); + + std::vector output_data_B(num_elements); + error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(), + output_data_B.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + error = clFinish(queue); + test_error(error, "clFinish failed"); + + for (size_t i = 0; i < num_elements; i++) + { + CHECK_VERIFICATION_ERROR(pattern_A, output_data_A[i], i); + + CHECK_VERIFICATION_ERROR(pattern_B, output_data_B[i], i); + } + return CL_SUCCESS; } -int test_interleaved_enqueue(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +bool ExplicitFlushTest::Skip() { - return MakeAndRunTest(device, context, queue, - num_elements); + return BasicCommandBufferTest::Skip() || !simultaneous_use_support; } -int test_mixed_commands(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +cl_int InterleavedEnqueueTest::Run() { - return MakeAndRunTest(device, context, queue, - num_elements); + cl_int error = clCommandNDRangeKernelKHR( + command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements, + nullptr, 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandNDRangeKernelKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + cl_int pattern = 42; + error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0, + data_size(), 0, nullptr, nullptr); + test_error(error, "clEnqueueFillBuffer failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + pattern = 0xABCD; + error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0, + data_size(), 0, nullptr, nullptr); + test_error(error, "clEnqueueFillBuffer failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr, + nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + error = clEnqueueCopyBuffer(queue, in_mem, out_mem, 0, 0, data_size(), 0, + nullptr, nullptr); + test_error(error, "clEnqueueCopyBuffer failed"); + + std::vector output_data(num_elements); + error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), + output_data.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < num_elements; i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; } -int test_explicit_flush(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +bool InterleavedEnqueueTest::Skip() { - return MakeAndRunTest(device, context, queue, - num_elements); + return BasicCommandBufferTest::Skip() || !simultaneous_use_support; } diff --git a/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.h b/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.h index f663e0a9..7ad7d28d 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.h +++ b/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.h @@ -84,6 +84,49 @@ protected: clCommandBufferWrapper command_buffer; }; +// Test that CL_COMMAND_BUFFER_FLAGS_KHR bitfield is parsed correctly when +// multiple flags are set. +struct MultiFlagCreationTest : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override; +}; + +// Test enqueuing a command-buffer containing a single NDRange command once +struct BasicEnqueueTest : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override; +}; + +// Test enqueuing a command-buffer containing multiple command, including +// operations other than NDRange kernel execution. +struct MixedCommandsTest : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override; +}; + +// Test flushing the command-queue between command-buffer enqueues +struct ExplicitFlushTest : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override; + bool Skip() override; +}; + +// Test enqueueing a command-buffer twice separated by another enqueue operation +struct InterleavedEnqueueTest : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override; + bool Skip() override; +}; template int MakeAndRunTest(cl_device_id device, cl_context context, diff --git a/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer_tests.cpp b/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer_tests.cpp new file mode 100644 index 00000000..0f95372a --- /dev/null +++ b/test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer_tests.cpp @@ -0,0 +1,46 @@ +// +// 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 "basic_command_buffer.h" + +REGISTER_TEST(multi_flag_creation) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} + +REGISTER_TEST(single_ndrange) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} + +REGISTER_TEST(interleaved_enqueue) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} + +REGISTER_TEST(mixed_commands) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} + +REGISTER_TEST(explicit_flush) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/main.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/main.cpp index 7ba7a4c6..0ae8d067 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/main.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/main.cpp @@ -12,43 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" #include "harness/testHarness.h" -test_definition test_list[] = { - ADD_TEST(mutable_command_info_device_query), - ADD_TEST(mutable_command_info_buffer), - ADD_TEST(mutable_command_properties_array), - ADD_TEST(mutable_command_kernel), - ADD_TEST(mutable_command_dimensions), - ADD_TEST(mutable_command_info_type), - ADD_TEST(mutable_command_info_queue), - ADD_TEST(mutable_command_info_global_work_offset), - ADD_TEST(mutable_command_info_local_work_size), - ADD_TEST(mutable_command_info_global_work_size), - ADD_TEST(mutable_command_full_dispatch), - ADD_TEST(mutable_command_overwrite_update), - ADD_TEST(mutable_command_multiple_dispatches), - ADD_TEST(mutable_command_iterative_arg_update), - ADD_TEST(mutable_dispatch_image_1d_arguments), - ADD_TEST(mutable_dispatch_image_2d_arguments), - ADD_TEST(mutable_dispatch_out_of_order), - ADD_TEST(mutable_dispatch_simultaneous_out_of_order), - ADD_TEST(mutable_dispatch_simultaneous_in_order), - ADD_TEST(mutable_dispatch_simultaneous_cross_queue), - ADD_TEST(mutable_dispatch_global_size), - ADD_TEST(mutable_dispatch_local_size), - ADD_TEST(mutable_dispatch_global_offset), - ADD_TEST(mutable_dispatch_svm_arguments), - ADD_TEST(mutable_dispatch_local_arguments), - ADD_TEST(mutable_dispatch_global_arguments), - ADD_TEST(mutable_dispatch_pod_arguments), - ADD_TEST(mutable_dispatch_null_arguments), - ADD_TEST(command_buffer_with_no_additional_work_groups), - ADD_TEST(ndrange_with_no_additional_work_groups), - ADD_TEST(ndrange_command_buffer_with_no_additional_work_groups), -}; - int main(int argc, const char *argv[]) { // A device may report the required properties of a queue that @@ -57,7 +22,9 @@ int main(int argc, const char *argv[]) // for this in the tests themselves, rather than here, where we have a // device to query. const cl_command_queue_properties queue_properties = 0; - return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list, + return runTestHarnessWithCheck(argc, argv, + test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, queue_properties, nullptr); return 0; } diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_arguments.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_arguments.cpp index e31205ee..48a121c6 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_arguments.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_arguments.cpp @@ -826,44 +826,31 @@ struct MutableDispatchSVMArguments : public MutableDispatchArgumentsTest } -int test_mutable_dispatch_local_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_local_arguments) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_dispatch_global_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_global_arguments) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_dispatch_pod_arguments(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_pod_arguments) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_dispatch_null_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_null_arguments) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_dispatch_svm_arguments(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_svm_arguments) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_full_dispatch.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_full_dispatch.cpp index ebf30a00..b5c8ecd9 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_full_dispatch.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_full_dispatch.cpp @@ -492,8 +492,7 @@ struct MutableCommandFullDispatch : InfoMutableCommandBufferTest } -int test_mutable_command_full_dispatch(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_command_full_dispatch) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_offset.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_offset.cpp index 1c7061ff..497ece9d 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_offset.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_offset.cpp @@ -160,9 +160,7 @@ struct MutableDispatchGlobalOffset : InfoMutableCommandBufferTest cl_mutable_command_khr command = nullptr; }; -int test_mutable_dispatch_global_offset(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_global_offset) { return MakeAndRunTest(device, context, queue, diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_size.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_size.cpp index 946fa995..8fb6b643 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_size.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_size.cpp @@ -159,8 +159,7 @@ struct MutableDispatchGlobalSize : public InfoMutableCommandBufferTest cl_mutable_command_khr command = nullptr; }; -int test_mutable_dispatch_global_size(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_dispatch_global_size) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_image_arguments.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_image_arguments.cpp index eb7cb266..6fe31948 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_image_arguments.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_image_arguments.cpp @@ -412,19 +412,13 @@ struct MutableDispatchImage2DArguments : public BasicMutableCommandBufferTest cl_mutable_command_khr command = nullptr; }; -int test_mutable_dispatch_image_1d_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_image_1d_arguments) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_dispatch_image_2d_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_image_2d_arguments) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_info.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_info.cpp index 12a982fa..f75457e6 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_info.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_info.cpp @@ -16,7 +16,6 @@ #include #include "typeWrappers.h" -#include "procs.h" #include "testHarness.h" #include #include @@ -441,76 +440,56 @@ struct InfoLocalWorkSize : public InfoMutableCommandBufferTest size_t test_local_work_size = 0; }; -int test_mutable_command_info_device_query(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_info_device_query) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_info_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_command_info_buffer) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_properties_array(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_properties_array) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_kernel(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_command_kernel) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_dimensions(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_command_dimensions) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_info_type(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_command_info_type) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_info_queue(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_command_info_queue) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_info_global_work_offset(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_info_global_work_offset) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_info_global_work_size(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_info_global_work_size) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_mutable_command_info_local_work_size(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_info_local_work_size) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_iterative_arg_update.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_iterative_arg_update.cpp index e7a8c035..1107d015 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_iterative_arg_update.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_iterative_arg_update.cpp @@ -212,10 +212,7 @@ struct IterativeArgUpdateDispatch : BasicMutableCommandBufferTest } -int test_mutable_command_iterative_arg_update(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_iterative_arg_update) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_local_size.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_local_size.cpp index 823517f5..ebddff57 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_local_size.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_local_size.cpp @@ -16,7 +16,6 @@ #include #include "typeWrappers.h" -#include "procs.h" #include "testHarness.h" #include "mutable_command_basic.h" #include @@ -166,8 +165,7 @@ struct MutableDispatchLocalSize : public InfoMutableCommandBufferTest cl_mutable_command_khr command = nullptr; }; -int test_mutable_dispatch_local_size(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_dispatch_local_size) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_multiple_dispatches.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_multiple_dispatches.cpp index 5ea0772d..08d1fc9f 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_multiple_dispatches.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_multiple_dispatches.cpp @@ -207,10 +207,7 @@ struct MultipleCommandsDispatch : BasicMutableCommandBufferTest } -int test_mutable_command_multiple_dispatches(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_multiple_dispatches) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_overwrite_update.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_overwrite_update.cpp index a3484e48..4a4b8b31 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_overwrite_update.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_overwrite_update.cpp @@ -215,10 +215,7 @@ struct OverwriteUpdateDispatch : BasicMutableCommandBufferTest } -int test_mutable_command_overwrite_update(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_command_overwrite_update) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_simultaneous.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_simultaneous.cpp index 9f0d806b..b4945e77 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_simultaneous.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_simultaneous.cpp @@ -605,35 +605,25 @@ struct CrossQueueSimultaneousMutableDispatchTest } // anonymous namespace -int test_mutable_dispatch_out_of_order(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(mutable_dispatch_out_of_order) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_mutable_dispatch_simultaneous_out_of_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_simultaneous_out_of_order) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_mutable_dispatch_simultaneous_in_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_simultaneous_in_order) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_mutable_dispatch_simultaneous_cross_queue(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(mutable_dispatch_simultaneous_cross_queue) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_work_groups.cpp b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_work_groups.cpp index ad20fbe3..f4f39321 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_work_groups.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_work_groups.cpp @@ -284,29 +284,21 @@ struct MutableDispatchWorkGroups : public BasicMutableCommandBufferTest const size_t sizeToAllocate = 64 * sizeof(cl_int); }; -int test_command_buffer_with_no_additional_work_groups(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(command_buffer_with_no_additional_work_groups) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_ndrange_with_no_additional_work_groups(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(ndrange_with_no_additional_work_groups) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_ndrange_command_buffer_with_no_additional_work_groups( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(ndrange_command_buffer_with_no_additional_work_groups) { return MakeAndRunTest>(device, context, queue, diff --git a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/procs.h b/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/procs.h deleted file mode 100644 index 8d49a799..00000000 --- a/test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/procs.h +++ /dev/null @@ -1,143 +0,0 @@ -// -// Copyright (c) 2023 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. -// -#ifndef CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H -#define CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H - -#include - - -// Basic mutable dispatch tests -extern int test_mutable_command_info_device_query(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_info_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_info_type(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_info_queue(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_properties_array(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_kernel(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_dimensions(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_info_global_work_offset(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_info_local_work_size(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_info_global_work_size(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_image_1d_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_image_2d_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_global_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_local_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_pod_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_null_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_svm_arguments(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_out_of_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_simultaneous_out_of_order( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_simultaneous_in_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_simultaneous_cross_queue( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_global_size(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_local_size(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_dispatch_global_offset(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_full_dispatch(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_overwrite_update(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_multiple_dispatches(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_mutable_command_iterative_arg_update(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_command_buffer_with_no_additional_work_groups( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_ndrange_with_no_additional_work_groups(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_ndrange_command_buffer_with_no_additional_work_groups( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); - -#endif /*_CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H*/ diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_event_sync.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_event_sync.cpp index 81f68cd4..00fda4dd 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_event_sync.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_event_sync.cpp @@ -15,7 +15,6 @@ // #include "basic_command_buffer.h" -#include "procs.h" #include #include @@ -823,10 +822,7 @@ struct CommandBufferEventSync : public BasicCommandBufferTest //-------------------------------------------------------------------------- // return-events test cases for regular queue -int test_regular_wait_for_command_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(regular_wait_for_command_buffer) { int status = TEST_PASS; // The approach here is that test scenario which involves out-of-order @@ -848,10 +844,7 @@ int test_regular_wait_for_command_buffer(cl_device_id device, return status; } -int test_command_buffer_wait_for_command_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(command_buffer_wait_for_command_buffer) { int status = TEST_PASS; // out-of-order command queue test @@ -871,10 +864,7 @@ int test_command_buffer_wait_for_command_buffer(cl_device_id device, return status; } -int test_command_buffer_wait_for_sec_command_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(command_buffer_wait_for_sec_command_buffer) { int status = TEST_PASS; // out-of-order command queue test @@ -894,8 +884,7 @@ int test_command_buffer_wait_for_sec_command_buffer(cl_device_id device, return status; } -int test_return_event_callback(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(return_event_callback) { int status = TEST_PASS; // out-of-order command queue test @@ -913,8 +902,7 @@ int test_return_event_callback(cl_device_id device, cl_context context, return status; } -int test_clwaitforevents_single(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(clwaitforevents_single) { int status = TEST_PASS; // out-of-order command queue test @@ -934,8 +922,7 @@ int test_clwaitforevents_single(cl_device_id device, cl_context context, return status; } -int test_clwaitforevents(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(clwaitforevents) { int status = TEST_PASS; // out-of-order command queue test @@ -953,10 +940,7 @@ int test_clwaitforevents(cl_device_id device, cl_context context, return status; } -int test_command_buffer_wait_for_regular(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(command_buffer_wait_for_regular) { int status = TEST_PASS; // out-of-order command queue test @@ -976,8 +960,7 @@ int test_command_buffer_wait_for_regular(cl_device_id device, return status; } -int test_wait_for_sec_queue_event(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(wait_for_sec_queue_event) { int status = TEST_PASS; // out-of-order command queue test @@ -1000,8 +983,7 @@ int test_wait_for_sec_queue_event(cl_device_id device, cl_context context, //-------------------------------------------------------------------------- // user-events test cases -int test_user_event_wait(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(user_event_wait) { int status = TEST_PASS; // out-of-order command queue test @@ -1019,8 +1001,7 @@ int test_user_event_wait(cl_device_id device, cl_context context, return status; } -int test_user_events_wait(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(user_events_wait) { int status = TEST_PASS; // out-of-order command queue test @@ -1038,8 +1019,7 @@ int test_user_events_wait(cl_device_id device, cl_context context, return status; } -int test_user_event_callback(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(user_event_callback) { int status = TEST_PASS; // out-of-order command queue test diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_finalize.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_finalize.cpp index bd669165..494a3779 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_finalize.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_finalize.cpp @@ -14,7 +14,6 @@ // limitations under the License. #include "basic_command_buffer.h" -#include "procs.h" namespace { @@ -71,15 +70,13 @@ struct FinalizeEmpty : public BasicCommandBufferTest }; } // anonymous namespace -int test_finalize_invalid(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(finalize_invalid) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_finalize_empty(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(finalize_empty) { return MakeAndRunTest(device, context, queue, num_elements); } diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_get_command_buffer_info.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_get_command_buffer_info.cpp index 63441970..88ea906b 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_get_command_buffer_info.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_get_command_buffer_info.cpp @@ -15,7 +15,6 @@ // #include "basic_command_buffer.h" -#include "procs.h" #include @@ -374,40 +373,35 @@ struct CommandBufferGetCommandBufferInfo : public BasicCommandBufferTest } // anonymous namespace -int test_info_queues(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(info_queues) { return MakeAndRunTest< CommandBufferGetCommandBufferInfo>( device, context, queue, num_elements); } -int test_info_ref_count(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(info_ref_count) { return MakeAndRunTest< CommandBufferGetCommandBufferInfo>( device, context, queue, num_elements); } -int test_info_state(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(info_state) { return MakeAndRunTest< CommandBufferGetCommandBufferInfo>( device, context, queue, num_elements); } -int test_info_prop_array(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(info_prop_array) { return MakeAndRunTest< CommandBufferGetCommandBufferInfo>( device, context, queue, num_elements); } -int test_info_context(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(info_context) { return MakeAndRunTest< CommandBufferGetCommandBufferInfo>( diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_out_of_order.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_out_of_order.cpp index e6cea227..60c43c8c 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_out_of_order.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_out_of_order.cpp @@ -15,7 +15,6 @@ // #include "basic_command_buffer.h" -#include "procs.h" #include @@ -337,15 +336,13 @@ struct OutOfOrderTest : public BasicCommandBufferTest } // anonymous namespace -int test_out_of_order(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(out_of_order) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_simultaneous_out_of_order(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(simultaneous_out_of_order) { return MakeAndRunTest>(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_printf.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_printf.cpp index a20e8d32..0621ba1d 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_printf.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_printf.cpp @@ -17,7 +17,6 @@ #include #include "basic_command_buffer.h" -#include "procs.h" #if !defined(_WIN32) #if defined(__APPLE__) @@ -524,15 +523,13 @@ struct CommandBufferPrintfTest : public BasicCommandBufferTest } // anonymous namespace -int test_basic_printf(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(basic_printf) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_simultaneous_printf(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(simultaneous_printf) { return MakeAndRunTest>(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_profiling.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_profiling.cpp index 199d2261..2c7f4b3c 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_profiling.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_profiling.cpp @@ -15,7 +15,6 @@ // #include "basic_command_buffer.h" -#include "procs.h" #include @@ -357,22 +356,19 @@ struct CommandBufferSubstituteQueueProfiling : public BasicCommandBufferTest }; } // anonymous namespace -int test_basic_profiling(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(basic_profiling) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_simultaneous_profiling(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(simultaneous_profiling) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_substitute_queue_profiling(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(substitute_queue_profiling) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_queue_substitution.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_queue_substitution.cpp index 1f74485b..22d19719 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_queue_substitution.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_queue_substitution.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include @@ -396,38 +395,31 @@ struct QueueOrderTest : public BasicCommandBufferTest }; } // anonymous namespace -int test_queue_substitution(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(queue_substitution) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_properties_queue_substitution(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(properties_queue_substitution) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_simultaneous_queue_substitution(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(simultaneous_queue_substitution) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_queue_substitute_in_order(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(queue_substitute_in_order) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_queue_substitute_out_of_order(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(queue_substitute_out_of_order) { return MakeAndRunTest>(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_set_kernel_arg.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_set_kernel_arg.cpp index ef938421..44954ce6 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_set_kernel_arg.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_set_kernel_arg.cpp @@ -15,7 +15,6 @@ // #include "basic_command_buffer.h" -#include "procs.h" #include @@ -306,15 +305,13 @@ struct CommandBufferSetKernelArg : public BasicCommandBufferTest } // anonymous namespace -int test_basic_set_kernel_arg(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(basic_set_kernel_arg) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_pending_set_kernel_arg(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(pending_set_kernel_arg) { return MakeAndRunTest>(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp index 8c420333..002e48f2 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include @@ -146,8 +145,7 @@ struct BarrierWithWaitListKHR : public BasicCommandBufferTest }; -int test_barrier_wait_list(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(barrier_wait_list) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp index c49974c8..de9a840b 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp @@ -16,7 +16,6 @@ #include "basic_command_buffer.h" #include "svm_command_basic.h" #include "harness/typeWrappers.h" -#include "procs.h" #include @@ -563,42 +562,36 @@ struct CopyBufferRectKHR : public BasicCommandBufferTest }; }; -int test_copy_image(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(copy_image) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_copy_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(copy_buffer) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_copy_svm_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(copy_svm_buffer) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_copy_buffer_to_image(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(copy_buffer_to_image) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_copy_image_to_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(copy_image_to_buffer) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_copy_buffer_rect(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(copy_buffer_rect) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_event_info.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_event_info.cpp index 19026ffe..80c047c2 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_event_info.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_event_info.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include namespace { @@ -222,33 +221,28 @@ struct ReferenceCount : public BasicCommandBufferTest }; }; -int test_event_info_command_type(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(event_info_command_type) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_event_info_command_queue(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(event_info_command_queue) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_event_info_context(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(event_info_context) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_event_info_execution_status(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(event_info_execution_status) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_event_info_reference_count(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(event_info_reference_count) { return MakeAndRunTest(device, context, queue, num_elements); } \ No newline at end of file diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp index d0311a65..53fe3995 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp @@ -16,7 +16,6 @@ #include "basic_command_buffer.h" #include "svm_command_basic.h" #include "harness/typeWrappers.h" -#include "procs.h" #include @@ -230,22 +229,19 @@ struct FillSVMBufferKHR : public BasicSVMCommandBufferTest }; }; -int test_fill_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(fill_buffer) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_fill_svm_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(fill_svm_buffer) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_fill_image(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(fill_image) { return MakeAndRunTest(device, context, queue, num_elements); } diff --git a/test_conformance/extensions/cl_khr_kernel_clock/procs.h b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_with_immutable_memory.h similarity index 50% rename from test_conformance/extensions/cl_khr_kernel_clock/procs.h rename to test_conformance/extensions/cl_khr_command_buffer/command_buffer_with_immutable_memory.h index a82564bc..bf6b238f 100644 --- a/test_conformance/extensions/cl_khr_kernel_clock/procs.h +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_with_immutable_memory.h @@ -1,3 +1,4 @@ +// // Copyright (c) 2024 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -11,17 +12,25 @@ // 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. -// -#ifndef CL_KHR_KERNEL_CLOCK_PROCS_H -#define CL_KHR_KERNEL_CLOCK_PROCS_H -#include +#pragma once -int test_device_scope(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -int test_workgroup_scope(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -int test_subgroup_scope(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); +#include "basic_command_buffer.h" +#include -#endif /*CL_KHR_KERNEL_CLOCK_PROCS_H*/ +template +struct CommandBufferWithImmutableMemoryObjectsTest : public TBase +{ + using TBase::TBase; + + static_assert(std::is_base_of::value, + "TBase must be BasicCommandBufferTest or a derived class"); + + bool Skip() override + { + bool is_immutable_memory_objects_supported = is_extension_available( + BasicCommandBufferTest::device, "cl_ext_immutable_memory_objects"); + + return !is_immutable_memory_objects_supported || TBase::Skip(); + } +}; diff --git a/test_conformance/extensions/cl_khr_command_buffer/main.cpp b/test_conformance/extensions/cl_khr_command_buffer/main.cpp index 941a9bb0..db4c45d9 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/main.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/main.cpp @@ -12,157 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" #include "harness/testHarness.h" -test_definition test_list[] = { - ADD_TEST(multi_flag_creation), - ADD_TEST(single_ndrange), - ADD_TEST(interleaved_enqueue), - ADD_TEST(mixed_commands), - ADD_TEST(explicit_flush), - ADD_TEST(out_of_order), - ADD_TEST(simultaneous_out_of_order), - ADD_TEST(info_queues), - ADD_TEST(info_ref_count), - ADD_TEST(info_state), - ADD_TEST(info_prop_array), - ADD_TEST(info_context), - ADD_TEST(basic_profiling), - ADD_TEST(simultaneous_profiling), - ADD_TEST(substitute_queue_profiling), - ADD_TEST(regular_wait_for_command_buffer), - ADD_TEST(command_buffer_wait_for_command_buffer), - ADD_TEST(command_buffer_wait_for_sec_command_buffer), - ADD_TEST(return_event_callback), - ADD_TEST(clwaitforevents_single), - ADD_TEST(clwaitforevents), - ADD_TEST(command_buffer_wait_for_regular), - ADD_TEST(wait_for_sec_queue_event), - ADD_TEST(user_event_wait), - ADD_TEST(user_events_wait), - ADD_TEST(user_event_callback), - ADD_TEST(queue_substitution), - ADD_TEST(properties_queue_substitution), - ADD_TEST(simultaneous_queue_substitution), - ADD_TEST(queue_substitute_in_order), - ADD_TEST(queue_substitute_out_of_order), - ADD_TEST(fill_image), - ADD_TEST(fill_buffer), - ADD_TEST(fill_svm_buffer), - ADD_TEST(copy_image), - ADD_TEST(copy_buffer), - ADD_TEST(copy_svm_buffer), - ADD_TEST(copy_buffer_to_image), - ADD_TEST(copy_image_to_buffer), - ADD_TEST(copy_buffer_rect), - ADD_TEST(barrier_wait_list), - ADD_TEST(basic_printf), - ADD_TEST(simultaneous_printf), - ADD_TEST(basic_set_kernel_arg), - ADD_TEST(pending_set_kernel_arg), - ADD_TEST(event_info_command_type), - ADD_TEST(event_info_command_queue), - ADD_TEST(event_info_execution_status), - ADD_TEST(event_info_context), - ADD_TEST(event_info_reference_count), - ADD_TEST(finalize_invalid), - ADD_TEST(finalize_empty), - // Command-buffer negative tests - ADD_TEST(negative_retain_command_buffer_invalid_command_buffer), - ADD_TEST(negative_release_command_buffer_invalid_command_buffer), - ADD_TEST(negative_finalize_command_buffer_invalid_command_buffer), - ADD_TEST(negative_finalize_command_buffer_not_recording_state), - ADD_TEST(negative_command_buffer_command_fill_buffer_queue_not_null), - ADD_TEST(negative_command_buffer_command_fill_buffer_context_not_same), - ADD_TEST( - negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero), - ADD_TEST( - negative_command_buffer_command_fill_buffer_invalid_command_buffer), - ADD_TEST( - negative_command_buffer_command_fill_buffer_finalized_command_buffer), - ADD_TEST( - negative_command_buffer_command_fill_buffer_mutable_handle_not_null), - ADD_TEST(negative_command_buffer_command_fill_image_queue_not_null), - ADD_TEST(negative_command_buffer_command_fill_image_context_not_same), - ADD_TEST( - negative_command_buffer_command_fill_image_sync_points_null_or_num_zero), - ADD_TEST(negative_command_buffer_command_fill_image_invalid_command_buffer), - ADD_TEST( - negative_command_buffer_command_fill_image_finalized_command_buffer), - ADD_TEST( - negative_command_buffer_command_fill_image_mutable_handle_not_null), - ADD_TEST(negative_create_command_buffer_num_queues), - ADD_TEST(negative_create_command_buffer_null_queues), - ADD_TEST(negative_create_command_buffer_repeated_properties), - ADD_TEST(negative_create_command_buffer_not_supported_properties), - ADD_TEST(negative_command_ndrange_queue_not_null), - ADD_TEST(negative_command_ndrange_kernel_with_different_context), - ADD_TEST(negative_command_ndrange_kernel_sync_points_null_or_num_zero), - ADD_TEST(negative_command_ndrange_kernel_invalid_command_buffer), - ADD_TEST(negative_command_ndrange_kernel_invalid_properties), - ADD_TEST(negative_command_ndrange_kernel_command_buffer_finalized), - ADD_TEST(negative_command_ndrange_kernel_mutable_handle_not_null), - ADD_TEST(negative_command_ndrange_kernel_not_support_printf), - ADD_TEST(negative_command_ndrange_kernel_with_enqueue_call), - ADD_TEST(negative_command_buffer_command_copy_buffer_queue_not_null), - ADD_TEST(negative_command_buffer_command_copy_buffer_different_contexts), - ADD_TEST( - negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero), - ADD_TEST( - negative_command_buffer_command_copy_buffer_invalid_command_buffer), - ADD_TEST( - negative_command_buffer_command_copy_buffer_finalized_command_buffer), - ADD_TEST( - negative_command_buffer_command_copy_buffer_mutable_handle_not_null), - ADD_TEST(negative_command_buffer_command_copy_image_queue_not_null), - ADD_TEST(negative_command_buffer_command_copy_image_different_contexts), - ADD_TEST( - negative_command_buffer_command_copy_image_sync_points_null_or_num_zero), - ADD_TEST(negative_command_buffer_command_copy_image_invalid_command_buffer), - ADD_TEST( - negative_command_buffer_command_copy_image_finalized_command_buffer), - ADD_TEST( - negative_command_buffer_command_copy_image_mutable_handle_not_null), - ADD_TEST(negative_get_command_buffer_info_invalid_command_buffer), - ADD_TEST(negative_get_command_buffer_info_not_supported_param_name), - ADD_TEST(negative_get_command_buffer_info_queues), - ADD_TEST(negative_get_command_buffer_info_ref_count), - ADD_TEST(negative_get_command_buffer_info_state), - ADD_TEST(negative_get_command_buffer_info_prop_array), - ADD_TEST(negative_get_command_buffer_info_context), - ADD_TEST(negative_command_buffer_command_svm_queue_not_null), - ADD_TEST(negative_command_buffer_command_svm_sync_points_null_or_num_zero), - ADD_TEST(negative_command_buffer_command_svm_invalid_command_buffer), - ADD_TEST(negative_command_buffer_command_svm_finalized_command_buffer), - ADD_TEST(negative_command_buffer_command_svm_mutable_handle_not_null), - ADD_TEST(negative_command_buffer_copy_image_queue_not_null), - ADD_TEST(negative_command_buffer_copy_image_context_not_same), - ADD_TEST(negative_command_buffer_copy_image_sync_points_null_or_num_zero), - ADD_TEST(negative_command_buffer_copy_image_invalid_command_buffer), - ADD_TEST(negative_command_buffer_copy_image_finalized_command_buffer), - ADD_TEST(negative_command_buffer_copy_image_mutable_handle_not_null), - ADD_TEST(negative_command_buffer_barrier_not_null_queue), - ADD_TEST(negative_command_buffer_barrier_invalid_command_buffer), - ADD_TEST(negative_command_buffer_barrier_buffer_finalized), - ADD_TEST(negative_command_buffer_barrier_mutable_handle_not_null), - ADD_TEST(negative_command_buffer_barrier_sync_points_null_or_num_zero), - ADD_TEST(negative_enqueue_command_buffer_invalid_command_buffer), - ADD_TEST(negative_enqueue_command_buffer_not_finalized), - ADD_TEST( - negative_enqueue_command_buffer_without_simultaneous_no_pending_state), - ADD_TEST(negative_enqueue_command_buffer_null_queues_num_queues), - ADD_TEST( - negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation), - ADD_TEST(negative_enqueue_command_buffer_not_valid_queue_in_queues), - ADD_TEST(negative_enqueue_queue_with_different_context), - ADD_TEST(negative_enqueue_command_buffer_different_context_than_event), - ADD_TEST(negative_enqueue_event_wait_list_null_or_events_null), - ADD_TEST(negative_enqueue_queue_without_reqd_properties), - ADD_TEST(negative_enqueue_with_unsupported_queue_property), - ADD_TEST(negative_enqueue_inconsistent_device), -}; - int main(int argc, const char *argv[]) { // A device may report the required properties of a queue that @@ -171,6 +22,8 @@ int main(int argc, const char *argv[]) // for this in the tests themselves, rather than here, where we have a // device to query. const cl_command_queue_properties queue_properties = 0; - return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list, + return runTestHarnessWithCheck(argc, argv, + test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, queue_properties, nullptr); } diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_barrier.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_barrier.cpp index ae0dc69d..5a55cc84 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_barrier.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_barrier.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include //-------------------------------------------------------------------------- @@ -159,42 +158,31 @@ struct CommandBufferBarrierSyncPointsNullOrNumZero }; }; -int test_negative_command_buffer_barrier_not_null_queue(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_barrier_not_null_queue) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_barrier_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_barrier_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_barrier_buffer_finalized( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_barrier_buffer_finalized) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_barrier_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_barrier_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_barrier_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_barrier_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy.cpp index 541ab516..7b7ec603 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy.cpp @@ -14,7 +14,9 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" +#include "command_buffer_with_immutable_memory.h" +#include "imageHelpers.h" +#include //-------------------------------------------------------------------------- template @@ -578,100 +580,359 @@ struct CommandBufferCopyImageMutableHandleNotNull return CL_SUCCESS; } }; + +struct CommandBufferCopyToImmutableImage + : public CommandBufferWithImmutableMemoryObjectsTest< + CommandBufferCopyBaseTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandFillImageKHR( + command_buffer, nullptr, nullptr, src_image, fill_color_1, origin, + region, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillImageKHR failed"); + + error = clCommandCopyImageKHR(command_buffer, nullptr, nullptr, + src_image, dst_image, origin, origin, + region, 0, 0, nullptr, nullptr); + + test_failure_error_ret(error, CL_INVALID_OPERATION, + "clCommandCopyImageKHR is supposed to fail " + "with CL_INVALID_OPERATION when dst_image is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + src_image = create_image_2d(context, CL_MEM_READ_ONLY, &format, + img_width, img_height, 0, nullptr, &error); + test_error(error, "create_image_2d failed"); + + size_t pixel_size = get_pixel_size(&format); + size_t image_size = + pixel_size * sizeof(cl_uchar) * img_width * img_height; + + std::vector imgptr(image_size); + + dst_image = create_image_2d( + context, CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, &format, + img_width, img_height, 0, imgptr.data(), &error); + test_error(error, "create_image_2d failed"); + + return CL_SUCCESS; + } + + clMemWrapper dst_image; + clMemWrapper src_image; + static constexpr cl_uint pattern_1 = 0x05; + const cl_uint fill_color_1[4] = { pattern_1, pattern_1, pattern_1, + pattern_1 }; +}; + +struct CommandBufferCopyToImmutableBuffer + : public CommandBufferWithImmutableMemoryObjectsTest< + CommandBufferCopyBaseTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandCopyBufferKHR(command_buffer, nullptr, nullptr, + in_mem, buffer, 0, 0, data_size, + 0, nullptr, nullptr, nullptr); + test_failure_error_ret(error, CL_INVALID_OPERATION, + "clCommandCopyBufferKHR is supposed to fail " + "with CL_INVALID_OPERATION when dst_buffer is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + in_mem = clCreateBuffer(context, CL_MEM_READ_ONLY, data_size, nullptr, + &error); + test_error(error, "clCreateBuffer failed"); + + std::vector data(data_size); + + buffer = + clCreateBuffer(context, CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, + data_size, data.data(), &error); + test_error(error, "clCreateBuffer failed"); + + return CL_SUCCESS; + } +}; + +struct CommandBufferCopyBufferToImmutableImage + : public CommandBufferWithImmutableMemoryObjectsTest< + CommandBufferCopyBaseTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, nullptr, buffer, &pattern_1, + sizeof(pattern_1), 0, data_size, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillBufferKHR failed"); + + error = clCommandCopyBufferToImageKHR(command_buffer, nullptr, nullptr, + buffer, image, 0, origin, region, + 0, 0, nullptr, nullptr); + + test_failure_error_ret( + error, CL_INVALID_OPERATION, + "clCommandCopyBufferToImageKHR is supposed to fail " + "with CL_INVALID_OPERATION when dst_image is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr, + &error); + test_error(error, "Unable to create buffer"); + + size_t pixel_size = get_pixel_size(&format); + size_t image_size = + pixel_size * sizeof(cl_uchar) * img_width * img_height; + + std::vector imgptr(image_size); + + image = create_image_2d( + context, CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, &format, + img_width, img_height, 0, imgptr.data(), &error); + test_error(error, "create_image_2d failed"); + + return CL_SUCCESS; + } + + const uint8_t pattern_1 = 0x05; +}; + +struct CommandBufferCopyImageToImmutableBuffer + : public CommandBufferWithImmutableMemoryObjectsTest< + CommandBufferCopyBaseTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandFillImageKHR( + command_buffer, nullptr, nullptr, image, fill_color_1, origin, + region, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillImageKHR failed"); + + error = clCommandCopyImageToBufferKHR(command_buffer, nullptr, nullptr, + image, buffer, origin, region, 0, + 0, nullptr, nullptr, nullptr); + + test_failure_error_ret( + error, CL_INVALID_OPERATION, + "clCommandCopyImageToBufferKHR is supposed to fail " + "with CL_INVALID_OPERATION when dst_buffer is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + image = create_image_2d(context, CL_MEM_READ_WRITE, &format, img_width, + img_height, 0, NULL, &error); + test_error(error, "create_image_2d failed"); + + std::vector data(data_size); + + buffer = + clCreateBuffer(context, CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, + data_size, data.data(), &error); + test_error(error, "Unable to create buffer"); + + return CL_SUCCESS; + } + + static constexpr cl_uint pattern_1 = 0x12; + const cl_uint fill_color_1[4] = { pattern_1, pattern_1, pattern_1, + pattern_1 }; +}; + +struct CommandBufferCopyToImmutableBufferRect + : public CommandBufferWithImmutableMemoryObjectsTest< + CommandBufferCopyBaseTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandCopyBufferRectKHR( + command_buffer, nullptr, nullptr, in_mem, buffer, origin, origin, + region, 0, 0, 0, 0, 0, nullptr, nullptr, nullptr); + test_failure_error_ret(error, CL_INVALID_OPERATION, + "clCommandCopyBufferRectKHR is supposed to fail " + "with CL_INVALID_OPERATION when dst_buffer is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + in_mem = clCreateBuffer(context, CL_MEM_READ_ONLY, data_size, nullptr, + &error); + test_error(error, "clCreateBuffer failed"); + + std::vector data(data_size); + + buffer = + clCreateBuffer(context, CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, + data_size, data.data(), &error); + test_error(error, "clCreateBuffer failed"); + + return CL_SUCCESS; + } +}; } -int test_negative_command_buffer_command_copy_buffer_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_copy_buffer_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_image_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_copy_image_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_buffer_different_contexts( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_copy_buffer_different_contexts) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_image_different_contexts( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_copy_image_different_contexts) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_image_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_image_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_buffer_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_image_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_copy_image_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_buffer_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_buffer_finalized_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_image_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_image_finalized_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_buffer_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_buffer_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_copy_image_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_copy_image_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } + +REGISTER_TEST(negative_copy_to_immutable_buffer) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} + +REGISTER_TEST(negative_copy_to_immutable_buffer_rect) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} + +REGISTER_TEST(negative_copy_image_to_immutable_buffer) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} + +REGISTER_TEST(negative_copy_to_immutable_image) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} + +REGISTER_TEST(negative_copy_buffer_to_immutable_image) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy_image.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy_image.cpp index 5103669e..472579f9 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy_image.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy_image.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include //-------------------------------------------------------------------------- @@ -384,49 +383,37 @@ struct CommandBufferCopyImageMutableHandleNotNull : public CommandCopyBaseTest }; } -int test_negative_command_buffer_copy_image_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_copy_image_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_copy_image_context_not_same( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_copy_image_context_not_same) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_copy_image_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_copy_image_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_copy_image_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_copy_image_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_copy_image_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_copy_image_finalized_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_copy_image_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_copy_image_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_create.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_create.cpp index 4b4727c7..fa087930 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_create.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_create.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" //-------------------------------------------------------------------------- @@ -199,35 +198,25 @@ struct CreateCommandBufferNotSupportedProperties : public BasicCommandBufferTest }; }; -int test_negative_create_command_buffer_num_queues(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_create_command_buffer_num_queues) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_negative_create_command_buffer_null_queues(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_create_command_buffer_null_queues) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_negative_create_command_buffer_repeated_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_create_command_buffer_repeated_properties) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_create_command_buffer_not_supported_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_create_command_buffer_not_supported_properties) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_enqueue.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_enqueue.cpp index cdc9398a..bb59118d 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_enqueue.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_enqueue.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" //-------------------------------------------------------------------------- namespace { @@ -614,103 +613,77 @@ struct EnqueueCommandBufferInconsistentDevice : public BasicCommandBufferTest }; }; -int test_negative_enqueue_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_command_buffer_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_command_buffer_not_finalized(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_command_buffer_not_finalized) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_command_buffer_without_simultaneous_no_pending_state( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_enqueue_command_buffer_without_simultaneous_no_pending_state) { return MakeAndRunTest< EnqueueCommandBufferWithoutSimultaneousUseNotInPendingState>( device, context, queue, num_elements); } -int test_negative_enqueue_command_buffer_null_queues_num_queues( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_command_buffer_null_queues_num_queues) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation) { return MakeAndRunTest< EnqueueCommandBufferNumQueuesNotZeroAndDifferentThanWhileBufferCreation>( device, context, queue, num_elements); } -int test_negative_enqueue_command_buffer_not_valid_queue_in_queues( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_command_buffer_not_valid_queue_in_queues) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_queue_with_different_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_queue_with_different_context) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_command_buffer_different_context_than_event( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_command_buffer_different_context_than_event) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_event_wait_list_null_or_events_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_event_wait_list_null_or_events_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_queue_without_reqd_properties(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_queue_without_reqd_properties) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_with_unsupported_queue_property( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_with_unsupported_queue_property) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_enqueue_inconsistent_device(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_enqueue_inconsistent_device) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_fill.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_fill.cpp index 23c282f0..ef14ade3 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_fill.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_fill.cpp @@ -14,7 +14,8 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" +#include "command_buffer_with_immutable_memory.h" +#include "imageHelpers.h" #include //-------------------------------------------------------------------------- @@ -457,101 +458,179 @@ struct CommandBufferCommandFillImageMutableHandleNotNull } }; +// CL_INVALID_OPERATION if destination buffer is immutable memory +struct CommandBufferCommandFillImmutableBuffer + : CommandBufferWithImmutableMemoryObjectsTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, nullptr, buffer, &pattern_1, + sizeof(pattern_1), 0, buffer_size, 0, nullptr, nullptr, nullptr); + + test_failure_error_ret(error, CL_INVALID_OPERATION, + "clCommandFillBufferKHR is supposed to fail " + "with CL_INVALID_OPERATION when buffer is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + std::vector data(buffer_size); + + buffer = + clCreateBuffer(context, CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, + buffer_size, data.data(), &error); + test_error(error, "clCreateBuffer failed"); + + return CL_SUCCESS; + } + + clMemWrapper buffer; + const size_t buffer_size = 512; + const uint8_t pattern_1 = 0x0f; +}; + +struct CommandBufferCommandFillImmutableImage + : CommandBufferWithImmutableMemoryObjectsTest> +{ + using CommandBufferWithImmutableMemoryObjectsTest:: + CommandBufferWithImmutableMemoryObjectsTest; + + cl_int Run() override + { + cl_int error = clCommandFillImageKHR( + command_buffer, nullptr, nullptr, image, fill_color_1, origin, + region, 0, nullptr, nullptr, nullptr); + + test_failure_error_ret(error, CL_INVALID_OPERATION, + "clCommandFillImageKHR is supposed to fail " + "with CL_INVALID_OPERATION when image is " + "created with CL_MEM_IMMUTABLE_EXT", + TEST_FAIL); + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + size_t pixel_size = get_pixel_size(&formats); + size_t image_size = pixel_size * sizeof(cl_uchar) * 512 * 512; + + std::vector imgptr(image_size); + + image = create_image_2d(context, + CL_MEM_IMMUTABLE_EXT | CL_MEM_COPY_HOST_PTR, + &formats, 512, 512, 0, imgptr.data(), &error); + test_error(error, "create_image_2d failed"); + + return CL_SUCCESS; + } + + clMemWrapper image; +}; } -int test_negative_command_buffer_command_fill_buffer_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_fill_buffer_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_image_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_fill_image_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_buffer_context_not_same( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_fill_buffer_context_not_same) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_image_context_not_same( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_fill_image_context_not_same) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero) { return MakeAndRunTest< CommandBufferCommandFillBufferSyncPointsNullOrNumZero>( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_image_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_image_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_buffer_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_image_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_fill_image_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_buffer_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_buffer_finalized_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_image_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_image_finalized_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_buffer_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_buffer_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_fill_image_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST( + negative_command_buffer_command_fill_image_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } + +REGISTER_TEST(negative_fill_immutable_image) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} + +REGISTER_TEST(negative_fill_immutable_buffer) +{ + return MakeAndRunTest( + device, context, queue, num_elements); +} diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_finalize.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_finalize.cpp index 35b59d7b..8d00ca86 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_finalize.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_finalize.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" //-------------------------------------------------------------------------- @@ -136,17 +135,13 @@ struct FinalizeCommandBufferNotRecordingState : public BasicCommandBufferTest }; }; -int test_negative_finalize_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_finalize_command_buffer_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_finalize_command_buffer_not_recording_state( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_finalize_command_buffer_not_recording_state) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_get_info.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_get_info.cpp index e00ca293..7726c377 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_get_info.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_get_info.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include //-------------------------------------------------------------------------- @@ -259,66 +258,47 @@ struct GetCommandBufferInfo : public BasicCommandBufferTest }; }; -int test_negative_get_command_buffer_info_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_get_command_buffer_info_not_supported_param_name( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_not_supported_param_name) { return MakeAndRunTest< GetCommandBufferInfo>( device, context, queue, num_elements); } -int test_negative_get_command_buffer_info_queues(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_queues) { return MakeAndRunTest< GetCommandBufferInfo>( device, context, queue, num_elements); } -int test_negative_get_command_buffer_info_ref_count(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_ref_count) { return MakeAndRunTest< GetCommandBufferInfo>( device, context, queue, num_elements); } -int test_negative_get_command_buffer_info_state(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_state) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_negative_get_command_buffer_info_prop_array(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_prop_array) { return MakeAndRunTest< GetCommandBufferInfo>( device, context, queue, num_elements); } -int test_negative_get_command_buffer_info_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_get_command_buffer_info_context) { return MakeAndRunTest< GetCommandBufferInfo>( diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_retain_release.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_retain_release.cpp index 04c11997..0b43c99a 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_retain_release.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_retain_release.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" //-------------------------------------------------------------------------- @@ -59,17 +58,13 @@ struct ReleaseCommandBufferInvalidCommandBuffer : public BasicCommandBufferTest }; }; -int test_negative_retain_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_retain_command_buffer_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_release_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_release_command_buffer_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_svm_mem.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_svm_mem.cpp index 26f1c257..b5d7812e 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_svm_mem.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_svm_mem.cpp @@ -15,7 +15,6 @@ // #include "basic_command_buffer.h" #include "svm_command_basic.h" -#include "procs.h" //-------------------------------------------------------------------------- @@ -234,41 +233,31 @@ struct CommandBufferCommandSVMMutableHandleNotNull }; } -int test_negative_command_buffer_command_svm_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_svm_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_svm_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_svm_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_svm_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_svm_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_svm_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_svm_finalized_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_buffer_command_svm_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_buffer_command_svm_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/negative_command_nd_range_kernel.cpp b/test_conformance/extensions/cl_khr_command_buffer/negative_command_nd_range_kernel.cpp index cb2bc62b..d3ba72b4 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/negative_command_nd_range_kernel.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/negative_command_nd_range_kernel.cpp @@ -14,7 +14,6 @@ // limitations under the License. // #include "basic_command_buffer.h" -#include "procs.h" #include "harness/featureHelpers.h" //-------------------------------------------------------------------------- @@ -459,74 +458,55 @@ enqueue_kernel(def_q, CLK_ENQUEUE_FLAGS_WAIT_KERNEL, ndrange, }; }; -int test_negative_command_ndrange_queue_not_null(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_queue_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_with_different_context( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_with_different_context) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_sync_points_null_or_num_zero) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_invalid_command_buffer) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_invalid_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_invalid_properties) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_command_buffer_finalized( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_command_buffer_finalized) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_mutable_handle_not_null) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_not_support_printf( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_not_support_printf) { return MakeAndRunTest( device, context, queue, num_elements); } -int test_negative_command_ndrange_kernel_with_enqueue_call( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(negative_command_ndrange_kernel_with_enqueue_call) { return MakeAndRunTest( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_command_buffer/procs.h b/test_conformance/extensions/cl_khr_command_buffer/procs.h deleted file mode 100644 index ba89de8e..00000000 --- a/test_conformance/extensions/cl_khr_command_buffer/procs.h +++ /dev/null @@ -1,410 +0,0 @@ -// -// Copyright (c) 2022 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. -// -#ifndef CL_KHR_COMMAND_BUFFER_PROCS_H -#define CL_KHR_COMMAND_BUFFER_PROCS_H - -#include - -// Basic command-buffer tests -extern int test_multi_flag_creation(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_single_ndrange(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_interleaved_enqueue(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_mixed_commands(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_explicit_flush(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_out_of_order(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_basic_printf(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_simultaneous_printf(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_info_queues(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_info_ref_count(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_info_state(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_info_prop_array(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_info_context(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_basic_set_kernel_arg(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_pending_set_kernel_arg(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_regular_wait_for_command_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_command_buffer_wait_for_command_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_command_buffer_wait_for_sec_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_return_event_callback(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_clwaitforevents_single(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_clwaitforevents(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_command_buffer_wait_for_regular(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_wait_for_sec_queue_event(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_user_event_wait(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_user_events_wait(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_user_event_callback(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_simultaneous_out_of_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_basic_profiling(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_simultaneous_profiling(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_substitute_queue_profiling(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_queue_substitution(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_properties_queue_substitution(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_simultaneous_queue_substitution(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_queue_substitute_in_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_queue_substitute_out_of_order(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_fill_image(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_fill_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_fill_svm_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_copy_image(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_copy_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_copy_svm_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_copy_buffer_to_image(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_copy_image_to_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_copy_buffer_rect(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_barrier_wait_list(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_event_info_command_type(cl_device_id device, cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_event_info_command_queue(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_event_info_context(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_event_info_execution_status(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_event_info_reference_count(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_finalize_invalid(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_finalize_empty(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements); -// Command-buffer negative tests -extern int test_negative_retain_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_release_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_finalize_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_finalize_command_buffer_not_recording_state( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_fill_buffer_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_fill_buffer_context_not_same( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_buffer_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_fill_image_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_buffer_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_fill_image_context_not_same( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_image_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_image_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_image_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_fill_image_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_create_command_buffer_num_queues( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_create_command_buffer_null_queues( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_create_command_buffer_repeated_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_create_command_buffer_not_supported_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_queue_not_null(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_with_different_context( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_invalid_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_command_buffer_finalized( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_not_support_printf( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_ndrange_kernel_with_enqueue_call( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_copy_buffer_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_copy_buffer_different_contexts( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_buffer_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_buffer_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_copy_image_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_copy_image_different_contexts( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_image_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_image_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_image_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_copy_image_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_not_supported_param_name( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_queues(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_ref_count( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_state(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_prop_array( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_get_command_buffer_info_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_svm_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_command_buffer_command_svm_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_svm_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_svm_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_command_svm_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_barrier_not_null_queue( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_barrier_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_barrier_buffer_finalized( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_barrier_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_barrier_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_command_buffer_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_command_buffer_not_finalized( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_enqueue_command_buffer_without_simultaneous_no_pending_state( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_command_buffer_null_queues_num_queues( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int -test_negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_copy_image_queue_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_copy_image_context_not_same( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_copy_image_sync_points_null_or_num_zero( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_copy_image_invalid_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_copy_image_finalized_command_buffer( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_command_buffer_copy_image_mutable_handle_not_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_command_buffer_not_valid_queue_in_queues( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_queue_with_different_context( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_command_buffer_different_context_than_event( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_event_wait_list_null_or_events_null( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_queue_without_reqd_properties( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_with_unsupported_queue_property( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_negative_enqueue_inconsistent_device(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -#endif // CL_KHR_COMMAND_BUFFER_PROCS_H diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/main.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/main.cpp index 8b709173..cc4b9377 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/main.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/main.cpp @@ -21,16 +21,6 @@ #include "procs.h" -test_definition test_list[] = { ADD_TEST(context_create), - ADD_TEST(get_device_ids), - ADD_TEST(api), - ADD_TEST(kernel), - ADD_TEST(other_data_types), - ADD_TEST(memory_access), - ADD_TEST(interop_user_sync) }; - -const int test_num = ARRAY_SIZE(test_list); - clGetDeviceIDsFromDX9MediaAdapterKHR_fn clGetDeviceIDsFromDX9MediaAdapterKHR = NULL; clCreateFromDX9MediaSurfaceKHR_fn clCreateFromDX9MediaSurfaceKHR = NULL; @@ -227,5 +217,6 @@ int main(int argc, const char *argv[]) if (!MediaSurfaceSharingExtensionInit()) return TEST_FAIL; - return runTestHarness(argc, argv, test_num, test_list, true, 0); + return runTestHarness(argc, argv, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), true, 0); } diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/procs.h b/test_conformance/extensions/cl_khr_dx9_media_sharing/procs.h index e7fd785e..e69de29b 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/procs.h +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/procs.h @@ -1,38 +0,0 @@ -// -// Copyright (c) 2019 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. -// - - -#ifndef __MEDIA_SHARING_PROCS_H__ -#define __MEDIA_SHARING_PROCS_H__ - - -extern int test_context_create(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_get_device_ids(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_api(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_kernel(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_other_data_types(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_memory_access(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_interop_user_sync(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); - - -#endif // #ifndef __MEDIA_SHARING_PROCS_H__ \ No newline at end of file diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_create_context.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_create_context.cpp index 310c0870..013163e7 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_create_context.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_create_context.cpp @@ -292,8 +292,7 @@ int context_create(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_context_create(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(context_create) { const unsigned int WIDTH = 256; const unsigned int HEIGHT = 256; @@ -341,8 +340,8 @@ int test_context_create(cl_device_id deviceID, cl_context context, continue; if (context_create( - deviceID, context, queue, num_elements, WIDTH, - HEIGHT, contextFuncs[contextFuncIdx], + device, context, queue, num_elements, WIDTH, HEIGHT, + contextFuncs[contextFuncIdx], adapterTypes[adapterTypeIdx], formats[formatIdx], sharedHandleTypes[sharedHandleIdx]) != 0) diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_api.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_api.cpp index 0f3fe4f6..b4a7fb9f 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_api.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_api.cpp @@ -674,14 +674,13 @@ int api_functions(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST(api) { CResult result; #if defined(_WIN32) // D3D9 - if (api_functions(deviceID, context, queue, num_elements, 10, 256, 256, + if (api_functions(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -690,7 +689,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 3, 512, 256, + if (api_functions(device, context, queue, num_elements, 3, 512, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -700,7 +699,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, } // D3D9EX - if (api_functions(deviceID, context, queue, num_elements, 5, 256, 512, + if (api_functions(device, context, queue, num_elements, 5, 256, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -709,7 +708,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 7, 512, 256, + if (api_functions(device, context, queue, num_elements, 7, 512, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_ENABLED) != 0) @@ -718,7 +717,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 10, 256, 256, + if (api_functions(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -727,7 +726,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 15, 128, 128, + if (api_functions(device, context, queue, num_elements, 15, 128, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_ENABLED) != 0) @@ -737,7 +736,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, } // DXVA - if (api_functions(deviceID, context, queue, num_elements, 20, 128, 128, + if (api_functions(device, context, queue, num_elements, 20, 128, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -746,7 +745,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 40, 64, 64, + if (api_functions(device, context, queue, num_elements, 40, 64, 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_ENABLED) != 0) @@ -755,7 +754,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 5, 512, 512, + if (api_functions(device, context, queue, num_elements, 5, 512, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -764,7 +763,7 @@ int test_api(cl_device_id deviceID, cl_context context, cl_command_queue queue, result.ResultSub(CResult::TEST_FAIL); } - if (api_functions(deviceID, context, queue, num_elements, 2, 1024, 1024, + if (api_functions(device, context, queue, num_elements, 2, 1024, 1024, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_ENABLED) != 0) diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_kernel.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_kernel.cpp index b8c97f80..d71ebe14 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_kernel.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_functions_kernel.cpp @@ -434,14 +434,13 @@ int kernel_functions(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_kernel(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(kernel) { CResult result; #if defined(_WIN32) // D3D9 - if (kernel_functions(deviceID, context, queue, num_elements, 10, 256, 256, + if (kernel_functions(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -450,7 +449,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 3, 256, 256, + if (kernel_functions(device, context, queue, num_elements, 3, 256, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -460,7 +459,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, } // D3D9EX - if (kernel_functions(deviceID, context, queue, num_elements, 5, 256, 512, + if (kernel_functions(device, context, queue, num_elements, 5, 256, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -469,7 +468,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 7, 512, 256, + if (kernel_functions(device, context, queue, num_elements, 7, 512, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_ENABLED) != 0) @@ -478,7 +477,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 10, 256, 256, + if (kernel_functions(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -487,7 +486,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 15, 128, 128, + if (kernel_functions(device, context, queue, num_elements, 15, 128, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_ENABLED) != 0) @@ -497,7 +496,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, } // DXVA - if (kernel_functions(deviceID, context, queue, num_elements, 20, 128, 128, + if (kernel_functions(device, context, queue, num_elements, 20, 128, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -506,7 +505,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 40, 64, 64, + if (kernel_functions(device, context, queue, num_elements, 40, 64, 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_ENABLED) != 0) @@ -515,7 +514,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 5, 512, 512, + if (kernel_functions(device, context, queue, num_elements, 5, 512, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -524,7 +523,7 @@ int test_kernel(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (kernel_functions(deviceID, context, queue, num_elements, 2, 1024, 1024, + if (kernel_functions(device, context, queue, num_elements, 2, 1024, 1024, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_ENABLED) != 0) diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_get_device_ids.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_get_device_ids.cpp index e8f1193e..1f0c1edd 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_get_device_ids.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_get_device_ids.cpp @@ -182,13 +182,12 @@ int get_device_ids(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_get_device_ids(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(get_device_ids) { CResult result; #if defined(_WIN32) - if (get_device_ids(deviceID, context, queue, num_elements, + if (get_device_ids(device, context, queue, num_elements, CL_ADAPTER_D3D9_KHR) != 0) { @@ -196,7 +195,7 @@ int test_get_device_ids(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (get_device_ids(deviceID, context, queue, num_elements, + if (get_device_ids(device, context, queue, num_elements, CL_ADAPTER_D3D9EX_KHR) != 0) { @@ -204,7 +203,7 @@ int test_get_device_ids(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (get_device_ids(deviceID, context, queue, num_elements, + if (get_device_ids(device, context, queue, num_elements, CL_ADAPTER_DXVA_KHR) != 0) { diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_interop_sync.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_interop_sync.cpp index 1147cc45..6d2d9dc8 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_interop_sync.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_interop_sync.cpp @@ -327,8 +327,7 @@ int interop_user_sync(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_interop_user_sync(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(interop_user_sync) { const unsigned int WIDTH = 256; const unsigned int HEIGHT = 256; @@ -382,7 +381,7 @@ int test_interop_user_sync(cl_device_id deviceID, cl_context context, continue; if (interop_user_sync( - deviceID, context, queue, num_elements, WIDTH, + device, context, queue, num_elements, WIDTH, HEIGHT, contextFuncs[contextFuncIdx], adapters[adapterIdx], formats[formatIdx], sharedHandleTypes[sharedHandleIdx], diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_memory_access.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_memory_access.cpp index 2833dcf1..e3791876 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_memory_access.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_memory_access.cpp @@ -442,14 +442,13 @@ int memory_access(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_memory_access(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(memory_access) { CResult result; #if defined(_WIN32) // D3D9 - if (memory_access(deviceID, context, queue, num_elements, 256, 256, + if (memory_access(device, context, queue, num_elements, 256, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -458,7 +457,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 512, 256, + if (memory_access(device, context, queue, num_elements, 512, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -468,7 +467,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, } // D3D9EX - if (memory_access(deviceID, context, queue, num_elements, 256, 512, + if (memory_access(device, context, queue, num_elements, 256, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -477,7 +476,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 512, 256, + if (memory_access(device, context, queue, num_elements, 512, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_ENABLED) != 0) @@ -486,7 +485,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 256, 256, + if (memory_access(device, context, queue, num_elements, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -495,7 +494,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 128, 128, + if (memory_access(device, context, queue, num_elements, 128, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_ENABLED) != 0) @@ -505,7 +504,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, } // DXVA - if (memory_access(deviceID, context, queue, num_elements, 128, 128, + if (memory_access(device, context, queue, num_elements, 128, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_DISABLED) != 0) @@ -514,7 +513,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 64, 64, + if (memory_access(device, context, queue, num_elements, 64, 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_NV12, SHARED_HANDLE_ENABLED) != 0) @@ -523,7 +522,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 512, 512, + if (memory_access(device, context, queue, num_elements, 512, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_DISABLED) != 0) @@ -532,7 +531,7 @@ int test_memory_access(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (memory_access(deviceID, context, queue, num_elements, 1024, 1024, + if (memory_access(device, context, queue, num_elements, 1024, 1024, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_YV12, SHARED_HANDLE_ENABLED) != 0) diff --git a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_other_data_types.cpp b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_other_data_types.cpp index 81807bcd..d00eabc8 100644 --- a/test_conformance/extensions/cl_khr_dx9_media_sharing/test_other_data_types.cpp +++ b/test_conformance/extensions/cl_khr_dx9_media_sharing/test_other_data_types.cpp @@ -527,15 +527,14 @@ int other_data_types(cl_device_id deviceID, cl_context context, return result.Result(); } -int test_other_data_types(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(other_data_types) { CResult result; #if defined(_WIN32) // D3D9 - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 256, CL_ADAPTER_D3D9_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_R32F, SHARED_HANDLE_DISABLED) != 0) { @@ -543,16 +542,16 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 256, 128, CL_ADAPTER_D3D9_KHR, - SURFACE_FORMAT_R16F, SHARED_HANDLE_DISABLED) + if (other_data_types(device, context, queue, num_elements, 10, 256, + 128, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_R16F, + SHARED_HANDLE_DISABLED) != 0) { log_error("\nTest case (D3D9, R16F, no shared handle) failed\n\n"); result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_L16, SHARED_HANDLE_DISABLED) != 0) @@ -561,7 +560,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 512, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A8, SHARED_HANDLE_DISABLED) != 0) @@ -570,7 +569,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 1024, 32, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_L8, SHARED_HANDLE_DISABLED) != 0) @@ -580,7 +579,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 32, 1024, + device, context, queue, num_elements, 10, 32, 1024, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_G32R32F, SHARED_HANDLE_DISABLED) != 0) { @@ -589,7 +588,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 64, 64, + device, context, queue, num_elements, 10, 64, 64, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_G16R16F, SHARED_HANDLE_DISABLED) != 0) { @@ -598,7 +597,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 256, 256, + device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_G16R16, SHARED_HANDLE_DISABLED) != 0) { @@ -606,7 +605,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 128, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A8L8, SHARED_HANDLE_DISABLED) != 0) @@ -615,7 +614,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 512, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A32B32G32R32F, SHARED_HANDLE_DISABLED) @@ -626,8 +625,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 128, 128, CL_ADAPTER_D3D9_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 128, + 128, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A16B16G16R16F, SHARED_HANDLE_DISABLED) != 0) @@ -637,7 +636,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 64, 128, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A16B16G16R16, SHARED_HANDLE_DISABLED) @@ -648,7 +647,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 64, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A8B8G8R8, SHARED_HANDLE_DISABLED) @@ -658,8 +657,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 16, 512, CL_ADAPTER_D3D9_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 16, + 512, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_X8B8G8R8, SHARED_HANDLE_DISABLED) != 0) @@ -668,7 +667,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 16, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_A8R8G8B8, SHARED_HANDLE_DISABLED) @@ -678,7 +677,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9_KHR, SURFACE_FORMAT_X8R8G8B8, SHARED_HANDLE_DISABLED) @@ -690,8 +689,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, // D3D9EX - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 256, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_R32F, SHARED_HANDLE_DISABLED) != 0) { @@ -699,8 +698,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 256, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_R32F, SHARED_HANDLE_ENABLED) != 0) { @@ -708,8 +707,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 256, 128, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 256, + 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_R16F, SHARED_HANDLE_DISABLED) != 0) { @@ -717,8 +716,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 256, 128, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 256, + 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_R16F, SHARED_HANDLE_ENABLED) != 0) { @@ -726,7 +725,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_L16, SHARED_HANDLE_DISABLED) != 0) @@ -735,7 +734,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_L16, SHARED_HANDLE_ENABLED) != 0) @@ -744,7 +743,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8, SHARED_HANDLE_DISABLED) != 0) @@ -753,7 +752,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8, SHARED_HANDLE_ENABLED) != 0) @@ -762,7 +761,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 1024, 32, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_L8, SHARED_HANDLE_DISABLED) != 0) @@ -771,7 +770,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 1024, 32, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_L8, SHARED_HANDLE_ENABLED) != 0) @@ -780,8 +779,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 32, 1024, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 32, + 1024, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_G32R32F, SHARED_HANDLE_DISABLED) != 0) @@ -790,8 +789,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 32, 1024, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 32, + 1024, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_G32R32F, SHARED_HANDLE_ENABLED) != 0) @@ -800,8 +799,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 64, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 64, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_G16R16F, SHARED_HANDLE_DISABLED) != 0) @@ -810,8 +809,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 64, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 64, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_G16R16F, SHARED_HANDLE_ENABLED) != 0) { @@ -819,7 +818,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_G16R16, SHARED_HANDLE_DISABLED) @@ -830,7 +829,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 256, 256, + device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_G16R16, SHARED_HANDLE_ENABLED) != 0) { @@ -838,7 +837,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8L8, SHARED_HANDLE_DISABLED) != 0) @@ -847,7 +846,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8L8, SHARED_HANDLE_ENABLED) != 0) @@ -856,7 +855,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A32B32G32R32F, SHARED_HANDLE_DISABLED) @@ -867,7 +866,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A32B32G32R32F, SHARED_HANDLE_ENABLED) @@ -878,8 +877,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 128, 128, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 128, + 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A16B16G16R16F, SHARED_HANDLE_DISABLED) != 0) @@ -889,8 +888,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 128, 128, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 128, + 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A16B16G16R16F, SHARED_HANDLE_ENABLED) != 0) @@ -900,7 +899,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 64, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A16B16G16R16, SHARED_HANDLE_DISABLED) @@ -911,7 +910,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 64, 128, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A16B16G16R16, SHARED_HANDLE_ENABLED) @@ -922,7 +921,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 64, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8B8G8R8, SHARED_HANDLE_DISABLED) @@ -933,7 +932,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 64, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8B8G8R8, SHARED_HANDLE_ENABLED) @@ -943,8 +942,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 16, 512, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 16, + 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_X8B8G8R8, SHARED_HANDLE_DISABLED) != 0) @@ -954,8 +953,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 16, 512, CL_ADAPTER_D3D9EX_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 16, + 512, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_X8B8G8R8, SHARED_HANDLE_ENABLED) != 0) @@ -964,7 +963,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 16, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8R8G8B8, SHARED_HANDLE_DISABLED) @@ -975,7 +974,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 16, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_A8R8G8B8, SHARED_HANDLE_ENABLED) @@ -985,7 +984,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_X8R8G8B8, SHARED_HANDLE_DISABLED) @@ -996,7 +995,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_D3D9EX_KHR, SURFACE_FORMAT_X8R8G8B8, SHARED_HANDLE_ENABLED) @@ -1008,8 +1007,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, // DXVA - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 256, CL_ADAPTER_DXVA_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_R32F, SHARED_HANDLE_DISABLED) != 0) { @@ -1017,8 +1016,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 256, CL_ADAPTER_DXVA_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_R32F, SHARED_HANDLE_ENABLED) != 0) { @@ -1026,25 +1025,25 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 256, 128, CL_ADAPTER_DXVA_KHR, - SURFACE_FORMAT_R16F, SHARED_HANDLE_DISABLED) + if (other_data_types(device, context, queue, num_elements, 10, 256, + 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_R16F, + SHARED_HANDLE_DISABLED) != 0) { log_error("\nTest case (DXVA, R16F, no shared handle) failed\n\n"); result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 256, 128, CL_ADAPTER_DXVA_KHR, - SURFACE_FORMAT_R16F, SHARED_HANDLE_ENABLED) + if (other_data_types(device, context, queue, num_elements, 10, 256, + 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_R16F, + SHARED_HANDLE_ENABLED) != 0) { log_error("\nTest case (DXVA, R16F, shared handle) failed\n\n"); result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_L16, SHARED_HANDLE_DISABLED) != 0) @@ -1053,7 +1052,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_L16, SHARED_HANDLE_ENABLED) != 0) @@ -1062,7 +1061,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8, SHARED_HANDLE_DISABLED) != 0) @@ -1071,7 +1070,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8, SHARED_HANDLE_ENABLED) != 0) @@ -1080,7 +1079,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 1024, 32, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_L8, SHARED_HANDLE_DISABLED) != 0) @@ -1089,7 +1088,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 1024, 32, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_L8, SHARED_HANDLE_ENABLED) != 0) @@ -1099,7 +1098,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 32, 1024, + device, context, queue, num_elements, 10, 32, 1024, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_G32R32F, SHARED_HANDLE_DISABLED) != 0) { @@ -1108,7 +1107,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 32, 1024, + device, context, queue, num_elements, 10, 32, 1024, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_G32R32F, SHARED_HANDLE_ENABLED) != 0) { @@ -1117,7 +1116,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 64, 64, + device, context, queue, num_elements, 10, 64, 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_G16R16F, SHARED_HANDLE_DISABLED) != 0) { @@ -1125,8 +1124,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 64, 64, CL_ADAPTER_DXVA_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 64, + 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_G16R16F, SHARED_HANDLE_ENABLED) != 0) { @@ -1135,7 +1134,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 256, 256, + device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_G16R16, SHARED_HANDLE_DISABLED) != 0) { @@ -1144,7 +1143,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 256, 256, + device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_G16R16, SHARED_HANDLE_ENABLED) != 0) { @@ -1152,7 +1151,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8L8, SHARED_HANDLE_DISABLED) != 0) @@ -1161,7 +1160,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8L8, SHARED_HANDLE_ENABLED) != 0) @@ -1170,7 +1169,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A32B32G32R32F, SHARED_HANDLE_DISABLED) @@ -1181,7 +1180,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A32B32G32R32F, SHARED_HANDLE_ENABLED) @@ -1192,8 +1191,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 128, 128, CL_ADAPTER_DXVA_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 128, + 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A16B16G16R16F, SHARED_HANDLE_DISABLED) != 0) @@ -1203,8 +1202,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 128, 128, CL_ADAPTER_DXVA_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 128, + 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A16B16G16R16F, SHARED_HANDLE_ENABLED) != 0) @@ -1214,7 +1213,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 64, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A16B16G16R16, SHARED_HANDLE_DISABLED) @@ -1225,7 +1224,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 64, 128, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A16B16G16R16, SHARED_HANDLE_ENABLED) @@ -1235,7 +1234,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 128, 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8B8G8R8, SHARED_HANDLE_DISABLED) @@ -1246,7 +1245,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 128, 64, + device, context, queue, num_elements, 10, 128, 64, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8B8G8R8, SHARED_HANDLE_ENABLED) != 0) { @@ -1254,8 +1253,8 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, - 16, 512, CL_ADAPTER_DXVA_KHR, + if (other_data_types(device, context, queue, num_elements, 10, 16, + 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_X8B8G8R8, SHARED_HANDLE_DISABLED) != 0) @@ -1265,7 +1264,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 16, 512, + device, context, queue, num_elements, 10, 16, 512, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_X8B8G8R8, SHARED_HANDLE_ENABLED) != 0) { @@ -1273,7 +1272,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 512, 16, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8R8G8B8, SHARED_HANDLE_DISABLED) @@ -1284,7 +1283,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 512, 16, + device, context, queue, num_elements, 10, 512, 16, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_A8R8G8B8, SHARED_HANDLE_ENABLED) != 0) { @@ -1292,7 +1291,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, result.ResultSub(CResult::TEST_FAIL); } - if (other_data_types(deviceID, context, queue, num_elements, 10, + if (other_data_types(device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_X8R8G8B8, SHARED_HANDLE_DISABLED) @@ -1303,7 +1302,7 @@ int test_other_data_types(cl_device_id deviceID, cl_context context, } if (other_data_types( - deviceID, context, queue, num_elements, 10, 256, 256, + device, context, queue, num_elements, 10, 256, 256, CL_ADAPTER_DXVA_KHR, SURFACE_FORMAT_X8R8G8B8, SHARED_HANDLE_ENABLED) != 0) { diff --git a/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt b/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt index 633dea33..1161e519 100644 --- a/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt +++ b/test_conformance/extensions/cl_khr_external_semaphore/CMakeLists.txt @@ -17,6 +17,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories (${CLConform_INCLUDE_DIR}) list(APPEND CLConform_LIBRARIES vulkan_wrapper) +set(CMAKE_COMPILE_WARNING_AS_ERROR OFF) set(CMAKE_CXX_FLAGS "-fpermissive") include_directories("../../common/vulkan_wrapper") diff --git a/test_conformance/extensions/cl_khr_external_semaphore/main.cpp b/test_conformance/extensions/cl_khr_external_semaphore/main.cpp index 4693ec16..db4c45d9 100644 --- a/test_conformance/extensions/cl_khr_external_semaphore/main.cpp +++ b/test_conformance/extensions/cl_khr_external_semaphore/main.cpp @@ -12,24 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" #include "harness/testHarness.h" -test_definition test_list[] = { - ADD_TEST_VERSION(external_semaphores_queries, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_cross_context, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_simple_1, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_simple_2, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_reuse, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_cross_queues_ooo, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_cross_queues_io, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_cross_queues_io2, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_multi_signal, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_multi_wait, Version(1, 2)), - ADD_TEST_VERSION(external_semaphores_import_export_fd, Version(1, 2)), -}; - - int main(int argc, const char *argv[]) { // A device may report the required properties of a queue that @@ -38,6 +22,8 @@ int main(int argc, const char *argv[]) // for this in the tests themselves, rather than here, where we have a // device to query. const cl_command_queue_properties queue_properties = 0; - return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list, + return runTestHarnessWithCheck(argc, argv, + test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, queue_properties, nullptr); } diff --git a/test_conformance/extensions/cl_khr_external_semaphore/procs.h b/test_conformance/extensions/cl_khr_external_semaphore/procs.h deleted file mode 100644 index fec89f75..00000000 --- a/test_conformance/extensions/cl_khr_external_semaphore/procs.h +++ /dev/null @@ -1,66 +0,0 @@ -// -// Copyright (c) 2022 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. -// -#ifndef CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H -#define CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H - -#include - -// Basic command-buffer tests - -extern int test_external_semaphores_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements); -extern int test_external_semaphores_cross_context(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements); -extern int test_external_semaphores_simple_1(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_simple_2(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_reuse(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_cross_queues_ooo(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_cross_queues_io(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_cross_queues_io2( - cl_device_id deviceID, cl_context context, cl_command_queue defaultQueue, - int num_elements); -extern int test_external_semaphores_multi_signal(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_multi_wait(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_external_semaphores_import_export_fd(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -#endif // CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H diff --git a/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp b/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp index e04449ea..7611fbf3 100644 --- a/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp +++ b/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore.cpp @@ -119,9 +119,7 @@ static cl_int get_device_semaphore_handle_types( } // Confirm the semaphores can be successfully queried -int test_external_semaphores_queries(cl_device_id device, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_queries, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_semaphore"); REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -199,10 +197,7 @@ int test_external_semaphores_queries(cl_device_id device, cl_context context, return TEST_PASS; } -int test_external_semaphores_cross_context(cl_device_id device, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_cross_context, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -325,9 +320,7 @@ int test_external_semaphores_cross_context(cl_device_id device, } // Confirm that a signal followed by a wait will complete successfully -int test_external_semaphores_simple_1(cl_device_id device, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_simple_1, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -361,10 +354,8 @@ int test_external_semaphores_simple_1(cl_device_id device, cl_context context, VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext(raw_sema_ext); + auto sema_ext = clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device); cl_int err = CL_SUCCESS; @@ -375,14 +366,13 @@ int test_external_semaphores_simple_1(cl_device_id device, cl_context context, // Signal semaphore clEventWrapper signal_event; - err = - clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), - nullptr, 0, nullptr, &signal_event); + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); test_error(err, "Could not signal semaphore"); // Wait semaphore clEventWrapper wait_event; - err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), nullptr, 0, nullptr, &wait_event); test_error(err, "Could not wait semaphore"); @@ -400,9 +390,7 @@ int test_external_semaphores_simple_1(cl_device_id device, cl_context context, // Confirm that signal a semaphore with no event dependencies will not result // in an implicit dependency on everything previously submitted -int test_external_semaphores_simple_2(cl_device_id device, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_simple_2, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -435,10 +423,8 @@ int test_external_semaphores_simple_2(cl_device_id device, cl_context context, VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext(raw_sema_ext); + auto sema_ext = clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device); cl_int err = CL_SUCCESS; @@ -465,14 +451,13 @@ int test_external_semaphores_simple_2(cl_device_id device, cl_context context, // Signal semaphore clEventWrapper signal_event; - err = - clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), - nullptr, 0, nullptr, &signal_event); + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); test_error(err, "Could not signal semaphore"); // Wait semaphore clEventWrapper wait_event; - err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), nullptr, 0, nullptr, &wait_event); test_error(err, "Could not wait semaphore"); @@ -507,9 +492,7 @@ int test_external_semaphores_simple_2(cl_device_id device, cl_context context, } // Confirm that a semaphore can be reused multiple times -int test_external_semaphores_reuse(cl_device_id device, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_reuse, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -542,10 +525,8 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context, VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext(raw_sema_ext); + auto sema_ext = clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device); cl_int err = CL_SUCCESS; @@ -571,9 +552,9 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context, test_error(err, "Unable to enqueue task_1"); // Signal semaphore (dependency on task_1) - err = clEnqueueSignalSemaphoresKHR( - queue, 1, &sema_ext->getCLSemaphore(), nullptr, 1, &task_events[0], - &signal_events[0]); + err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), + nullptr, 1, &task_events[0], + &signal_events[0]); test_error(err, "Could not signal semaphore"); // In a loop @@ -582,7 +563,7 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context, { // Wait semaphore err = clEnqueueWaitSemaphoresKHR( - queue, 1, &sema_ext->getCLSemaphore(), nullptr, 0, nullptr, + queue, 1, &sema_ext.getCLSemaphore(), nullptr, 0, nullptr, &wait_events[loop - 1]); test_error(err, "Could not wait semaphore"); @@ -597,13 +578,13 @@ int test_external_semaphores_reuse(cl_device_id device, cl_context context, // Signal semaphore (dependency on task_loop) err = clEnqueueSignalSemaphoresKHR( - queue, 1, &sema_ext->getCLSemaphore(), nullptr, 1, + queue, 1, &sema_ext.getCLSemaphore(), nullptr, 1, &task_events[loop], &signal_events[loop]); test_error(err, "Could not signal semaphore"); } // Wait semaphore - err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext->getCLSemaphore(), + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext.getCLSemaphore(), nullptr, 0, nullptr, &wait_events[loop - 1]); test_error(err, "Could not wait semaphore"); @@ -662,25 +643,22 @@ static int external_semaphore_cross_queue_helper(cl_device_id device, VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext(raw_sema_ext); + auto sema_ext = clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device); cl_int err = CL_SUCCESS; // Signal semaphore on queue_1 clEventWrapper signal_event; - err = clEnqueueSignalSemaphoresKHR(queue_1, 1, - &sema_ext->getCLSemaphore(), nullptr, - 0, nullptr, &signal_event); + err = + clEnqueueSignalSemaphoresKHR(queue_1, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &signal_event); test_error(err, "Could not signal semaphore"); // Wait semaphore on queue_2 clEventWrapper wait_event; - err = - clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext->getCLSemaphore(), - nullptr, 0, nullptr, &wait_event); + err = clEnqueueWaitSemaphoresKHR(queue_2, 1, &sema_ext.getCLSemaphore(), + nullptr, 0, nullptr, &wait_event); test_error(err, "Could not wait semaphore"); // Finish queue_1 and queue_2 @@ -700,51 +678,42 @@ static int external_semaphore_cross_queue_helper(cl_device_id device, // Confirm that a semaphore works across different ooo queues -int test_external_semaphores_cross_queues_ooo(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_cross_queues_ooo, Version(1, 2)) { cl_int err; // Create ooo queues clCommandQueueWrapper queue_1 = clCreateCommandQueue( - context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); test_error(err, "Could not create command queue"); clCommandQueueWrapper queue_2 = clCreateCommandQueue( - context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); test_error(err, "Could not create command queue"); - return external_semaphore_cross_queue_helper(deviceID, context, queue_1, + return external_semaphore_cross_queue_helper(device, context, queue_1, queue_2); } // Confirm that a semaphore works across different in-order queues -int test_external_semaphores_cross_queues_io(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_cross_queues_io, Version(1, 2)) { cl_int err; // Create in-order queues clCommandQueueWrapper queue_1 = - clCreateCommandQueue(context, deviceID, 0, &err); + clCreateCommandQueue(context, device, 0, &err); test_error(err, "Could not create command queue"); clCommandQueueWrapper queue_2 = - clCreateCommandQueue(context, deviceID, 0, &err); + clCreateCommandQueue(context, device, 0, &err); test_error(err, "Could not create command queue"); - return external_semaphore_cross_queue_helper(deviceID, context, queue_1, + return external_semaphore_cross_queue_helper(device, context, queue_1, queue_2); } -int test_external_semaphores_cross_queues_io2(cl_device_id device, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_cross_queues_io2, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -786,15 +755,11 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device, VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext_1 = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext_1(raw_sema_ext_1); + auto sema_ext_1 = clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, device); - clExternalSemaphore *raw_sema_ext_2 = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore, context2, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext_2(raw_sema_ext_2); + auto sema_ext_2 = clExternalImportableSemaphore( + vkVk2CLSemaphore, context2, vkExternalSemaphoreHandleType, device); clCommandQueueWrapper queue1 = clCreateCommandQueue(context, device, 0, &err); @@ -807,28 +772,28 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device, // Signal semaphore 1 clEventWrapper signal_1_event; err = clEnqueueSignalSemaphoresKHR( - queue1, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr, + queue1, 1, &sema_ext_1.getCLSemaphore(), nullptr, 0, nullptr, &signal_1_event); test_error(err, "Could not signal semaphore"); // Wait semaphore 1 clEventWrapper wait_1_event; err = - clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1->getCLSemaphore(), + clEnqueueWaitSemaphoresKHR(queue1, 1, &sema_ext_1.getCLSemaphore(), nullptr, 0, nullptr, &wait_1_event); test_error(err, "Could not wait semaphore"); // Signal semaphore 2 clEventWrapper signal_2_event; err = clEnqueueSignalSemaphoresKHR( - queue2, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr, + queue2, 1, &sema_ext_2.getCLSemaphore(), nullptr, 0, nullptr, &signal_2_event); test_error(err, "Could not signal semaphore"); // Wait semaphore 2 clEventWrapper wait_2_event; err = - clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2->getCLSemaphore(), + clEnqueueWaitSemaphoresKHR(queue2, 1, &sema_ext_2.getCLSemaphore(), nullptr, 0, nullptr, &wait_2_event); test_error(err, "Could not wait semaphore"); @@ -850,10 +815,7 @@ int test_external_semaphores_cross_queues_io2(cl_device_id device, } // Confirm that we can signal multiple semaphores with one command -int test_external_semaphores_multi_signal(cl_device_id device, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_multi_signal, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -888,15 +850,11 @@ int test_external_semaphores_multi_signal(cl_device_id device, VulkanSemaphore vkVk2CLSemaphore2(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext_1 = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore1, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext_1(raw_sema_ext_1); + auto sema_ext_1 = clExternalImportableSemaphore( + vkVk2CLSemaphore1, context, vkExternalSemaphoreHandleType, device); - clExternalSemaphore *raw_sema_ext_2 = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore2, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext_2(raw_sema_ext_2); + auto sema_ext_2 = clExternalImportableSemaphore( + vkVk2CLSemaphore2, context, vkExternalSemaphoreHandleType, device); cl_int err = CL_SUCCESS; @@ -907,24 +865,22 @@ int test_external_semaphores_multi_signal(cl_device_id device, // Signal semaphore 1 and 2 clEventWrapper signal_event; - cl_semaphore_khr sema_list[] = { sema_ext_1->getCLSemaphore(), - sema_ext_2->getCLSemaphore() }; + cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(), + sema_ext_2.getCLSemaphore() }; err = clEnqueueSignalSemaphoresKHR(queue, 2, sema_list, nullptr, 0, nullptr, &signal_event); test_error(err, "Could not signal semaphore"); // Wait semaphore 1 clEventWrapper wait_1_event; - err = - clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1->getCLSemaphore(), - nullptr, 0, nullptr, &wait_1_event); + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &wait_1_event); test_error(err, "Could not wait semaphore"); // Wait semaphore 2 clEventWrapper wait_2_event; - err = - clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2->getCLSemaphore(), - nullptr, 0, nullptr, &wait_2_event); + err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &wait_2_event); test_error(err, "Could not wait semaphore"); // Finish @@ -941,9 +897,7 @@ int test_external_semaphores_multi_signal(cl_device_id device, } // Confirm that we can wait for multiple semaphores with one command -int test_external_semaphores_multi_wait(cl_device_id device, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_multi_wait, Version(1, 2)) { REQUIRE_EXTENSION("cl_khr_external_semaphore"); @@ -978,15 +932,11 @@ int test_external_semaphores_multi_wait(cl_device_id device, cl_context context, VulkanSemaphore vkVk2CLSemaphore2(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *raw_sema_ext_1 = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext_1, vkVk2CLSemaphore1, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext_1(raw_sema_ext_1); + auto sema_ext_1 = clExternalImportableSemaphore( + vkVk2CLSemaphore1, context, vkExternalSemaphoreHandleType, device); - clExternalSemaphore *raw_sema_ext_2 = NULL; - CREATE_OPENCL_SEMAPHORE(raw_sema_ext_2, vkVk2CLSemaphore2, context, - vkExternalSemaphoreHandleType, device, true); - std::unique_ptr sema_ext_2(raw_sema_ext_2); + auto sema_ext_2 = clExternalImportableSemaphore( + vkVk2CLSemaphore2, context, vkExternalSemaphoreHandleType, device); cl_int err = CL_SUCCESS; @@ -997,22 +947,22 @@ int test_external_semaphores_multi_wait(cl_device_id device, cl_context context, // Signal semaphore 1 clEventWrapper signal_1_event; - err = clEnqueueSignalSemaphoresKHR( - queue, 1, &sema_ext_1->getCLSemaphore(), nullptr, 0, nullptr, - &signal_1_event); + err = + clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_1.getCLSemaphore(), + nullptr, 0, nullptr, &signal_1_event); test_error(err, "Could not signal semaphore"); // Signal semaphore 2 clEventWrapper signal_2_event; - err = clEnqueueSignalSemaphoresKHR( - queue, 1, &sema_ext_2->getCLSemaphore(), nullptr, 0, nullptr, - &signal_2_event); + err = + clEnqueueSignalSemaphoresKHR(queue, 1, &sema_ext_2.getCLSemaphore(), + nullptr, 0, nullptr, &signal_2_event); test_error(err, "Could not signal semaphore"); // Wait semaphore 1 and 2 clEventWrapper wait_event; - cl_semaphore_khr sema_list[] = { sema_ext_1->getCLSemaphore(), - sema_ext_2->getCLSemaphore() }; + cl_semaphore_khr sema_list[] = { sema_ext_1.getCLSemaphore(), + sema_ext_2.getCLSemaphore() }; err = clEnqueueWaitSemaphoresKHR(queue, 2, sema_list, nullptr, 0, nullptr, &wait_event); test_error(err, "Could not wait semaphore"); diff --git a/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore_sync_fd.cpp b/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore_sync_fd.cpp index 0419c615..2fcf4f3f 100644 --- a/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore_sync_fd.cpp +++ b/test_conformance/extensions/cl_khr_external_semaphore/test_external_semaphore_sync_fd.cpp @@ -20,14 +20,11 @@ // Test it is possible to export a semaphore to a sync fd and import the same // sync fd to a new semaphore -int test_external_semaphores_import_export_fd(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(external_semaphores_import_export_fd, Version(1, 2)) { cl_int err = CL_SUCCESS; - if (!is_extension_available(deviceID, "cl_khr_external_semaphore")) + if (!is_extension_available(device, "cl_khr_external_semaphore")) { log_info( "cl_khr_external_semaphore is not supported on this platoform. " @@ -35,7 +32,7 @@ int test_external_semaphores_import_export_fd(cl_device_id deviceID, return TEST_SKIPPED_ITSELF; } - if (!is_extension_available(deviceID, "cl_khr_external_semaphore_sync_fd")) + if (!is_extension_available(device, "cl_khr_external_semaphore_sync_fd")) { log_info("cl_khr_external_semaphore_sync_fd is not supported on this " "platoform. Skipping test.\n"); @@ -43,7 +40,7 @@ int test_external_semaphores_import_export_fd(cl_device_id deviceID, } cl_command_queue_properties device_props = 0; - err = clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_PROPERTIES, + err = clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES, sizeof(device_props), &device_props, NULL); test_error(err, "clGetDeviceInfo for CL_DEVICE_QUEUE_PROPERTIES failed"); @@ -55,15 +52,15 @@ int test_external_semaphores_import_export_fd(cl_device_id deviceID, } // Obtain pointers to semaphore's API - GET_PFN(deviceID, clCreateSemaphoreWithPropertiesKHR); - GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR); - GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR); - GET_PFN(deviceID, clGetSemaphoreHandleForTypeKHR); - GET_PFN(deviceID, clReleaseSemaphoreKHR); + GET_PFN(device, clCreateSemaphoreWithPropertiesKHR); + GET_PFN(device, clEnqueueSignalSemaphoresKHR); + GET_PFN(device, clEnqueueWaitSemaphoresKHR); + GET_PFN(device, clGetSemaphoreHandleForTypeKHR); + GET_PFN(device, clReleaseSemaphoreKHR); // Create ooo queue - clCommandQueueWrapper queue = clCreateCommandQueue( - context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); + clCommandQueueWrapper test_queue = clCreateCommandQueue( + context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err); test_error(err, "Could not create command queue"); // Create semaphore @@ -84,14 +81,14 @@ int test_external_semaphores_import_export_fd(cl_device_id deviceID, // Signal semaphore clEventWrapper signal_event; - err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema_1, nullptr, 0, nullptr, - &signal_event); + err = clEnqueueSignalSemaphoresKHR(test_queue, 1, &sema_1, nullptr, 0, + nullptr, &signal_event); test_error(err, "Could not signal semaphore"); // Extract sync fd int handle = -1; size_t handle_size; - err = clGetSemaphoreHandleForTypeKHR(sema_1, deviceID, + err = clGetSemaphoreHandleForTypeKHR(sema_1, device, CL_SEMAPHORE_HANDLE_SYNC_FD_KHR, sizeof(handle), &handle, &handle_size); test_error(err, "Could not extract semaphore handle"); @@ -112,12 +109,12 @@ int test_external_semaphores_import_export_fd(cl_device_id deviceID, // Wait semaphore clEventWrapper wait_event; - err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema_2, nullptr, 0, nullptr, - &wait_event); + err = clEnqueueWaitSemaphoresKHR(test_queue, 1, &sema_2, nullptr, 0, + nullptr, &wait_event); test_error(err, "Could not wait semaphore"); // Finish - err = clFinish(queue); + err = clFinish(test_queue); test_error(err, "Could not finish queue"); // Check all events are completed diff --git a/test_conformance/extensions/cl_khr_kernel_clock/kernel_clock.cpp b/test_conformance/extensions/cl_khr_kernel_clock/kernel_clock.cpp index 744083a9..c8c6448a 100644 --- a/test_conformance/extensions/cl_khr_kernel_clock/kernel_clock.cpp +++ b/test_conformance/extensions/cl_khr_kernel_clock/kernel_clock.cpp @@ -12,7 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" #include "harness/typeWrappers.h" namespace { @@ -173,22 +172,19 @@ int MakeAndRunTest(cl_device_id device, cl_context context, } -int test_device_scope(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(device_scope) { return MakeAndRunTest(device, context, queue, CL_DEVICE_KERNEL_CLOCK_SCOPE_DEVICE_KHR); } -int test_workgroup_scope(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(workgroup_scope) { return MakeAndRunTest(device, context, queue, CL_DEVICE_KERNEL_CLOCK_SCOPE_WORK_GROUP_KHR); } -int test_subgroup_scope(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(subgroup_scope) { return MakeAndRunTest(device, context, queue, CL_DEVICE_KERNEL_CLOCK_SCOPE_SUB_GROUP_KHR); diff --git a/test_conformance/extensions/cl_khr_kernel_clock/main.cpp b/test_conformance/extensions/cl_khr_kernel_clock/main.cpp index 8a2d9855..d188be6d 100644 --- a/test_conformance/extensions/cl_khr_kernel_clock/main.cpp +++ b/test_conformance/extensions/cl_khr_kernel_clock/main.cpp @@ -12,18 +12,10 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "procs.h" #include "harness/testHarness.h" -test_definition test_list[] = { - ADD_TEST(device_scope), - ADD_TEST(workgroup_scope), - ADD_TEST(subgroup_scope), -}; - - int main(int argc, const char *argv[]) { - return runTestHarness(argc, argv, ARRAY_SIZE(test_list), test_list, false, - 0); + return runTestHarness(argc, argv, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0); } diff --git a/test_conformance/extensions/cl_khr_semaphore/main.cpp b/test_conformance/extensions/cl_khr_semaphore/main.cpp index 0952729b..dc1316c4 100644 --- a/test_conformance/extensions/cl_khr_semaphore/main.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/main.cpp @@ -13,71 +13,10 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" -#include -#include - -#include -#include "procs.h" #include "harness/testHarness.h" -#if !defined(_WIN32) -#include -#endif - -test_definition test_list[] = { - ADD_TEST_VERSION(semaphores_simple_1, Version(1, 2)), - ADD_TEST_VERSION(semaphores_simple_2, Version(1, 2)), - ADD_TEST_VERSION(semaphores_reuse, Version(1, 2)), - ADD_TEST_VERSION(semaphores_cross_queues_ooo, Version(1, 2)), - ADD_TEST_VERSION(semaphores_cross_queues_io, Version(1, 2)), - ADD_TEST_VERSION(semaphores_multi_signal, Version(1, 2)), - ADD_TEST_VERSION(semaphores_multi_wait, Version(1, 2)), - ADD_TEST_VERSION(semaphores_device_list_queries, Version(1, 2)), - ADD_TEST_VERSION(semaphores_no_device_list_queries, Version(1, 2)), - ADD_TEST_VERSION(semaphores_multi_device_context_queries, Version(1, 2)), - ADD_TEST_VERSION(semaphores_ooo_ops_single_queue, Version(1, 2)), - ADD_TEST_VERSION(semaphores_ooo_ops_cross_queue, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_invalid_context, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_invalid_property, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_multi_device_property, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_invalid_device, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_import_invalid_device, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_invalid_value, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_create_invalid_operation, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_get_info_invalid_semaphore, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_get_info_invalid_value, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_wait_invalid_command_queue, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_wait_invalid_value, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_wait_invalid_semaphore, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_wait_invalid_context, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_wait_invalid_event_wait_list, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_wait_invalid_event_status, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_signal_invalid_command_queue, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_signal_invalid_value, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_signal_invalid_semaphore, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_signal_invalid_context, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_signal_invalid_event_wait_list, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_signal_invalid_event_status, - Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_release, Version(1, 2)), - ADD_TEST_VERSION(semaphores_negative_retain, Version(1, 2)), -}; - -const int test_num = ARRAY_SIZE(test_list); - int main(int argc, const char *argv[]) { - return runTestHarness(argc, argv, test_num, test_list, false, 0); + return runTestHarness(argc, argv, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0); } diff --git a/test_conformance/extensions/cl_khr_semaphore/procs.h b/test_conformance/extensions/cl_khr_semaphore/procs.h deleted file mode 100644 index 29047b95..00000000 --- a/test_conformance/extensions/cl_khr_semaphore/procs.h +++ /dev/null @@ -1,140 +0,0 @@ -// -// Copyright (c) 2023 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/errorHelpers.h" -#include "harness/kernelHelpers.h" -#include "harness/typeWrappers.h" -#include "harness/clImageHelper.h" -#include "harness/imageHelpers.h" - -extern int test_semaphores_simple_1(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_semaphores_simple_2(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_semaphores_reuse(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_semaphores_cross_queues_ooo(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_cross_queues_io(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_multi_signal(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_multi_wait(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); -extern int test_semaphores_device_list_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_no_device_list_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_multi_device_context_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_import_export_fd(cl_device_id deviceID, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_invalid_context( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_invalid_property( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_multi_device_property( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_invalid_device( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_import_invalid_device( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_create_invalid_operation( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_get_info_invalid_semaphore( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_get_info_invalid_value( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_wait_invalid_command_queue( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_wait_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_wait_invalid_semaphore( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_wait_invalid_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_wait_invalid_event_wait_list( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_wait_invalid_event_status( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_signal_invalid_command_queue( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_signal_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_signal_invalid_semaphore( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_signal_invalid_context( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_signal_invalid_event_wait_list( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_signal_invalid_event_status( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_release(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_negative_retain(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements); -extern int test_semaphores_ooo_ops_single_queue(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements); -extern int test_semaphores_ooo_ops_cross_queue(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements); diff --git a/test_conformance/extensions/cl_khr_semaphore/semaphore_base.h b/test_conformance/extensions/cl_khr_semaphore/semaphore_base.h index 6e88b22c..372bdd1e 100644 --- a/test_conformance/extensions/cl_khr_semaphore/semaphore_base.h +++ b/test_conformance/extensions/cl_khr_semaphore/semaphore_base.h @@ -24,26 +24,6 @@ #include "harness/testHarness.h" #include "harness/typeWrappers.h" -// scope guard helper to ensure proper releasing of sub devices -struct SubDevicesScopeGuarded -{ - SubDevicesScopeGuarded(const cl_int dev_count) - { - sub_devices.resize(dev_count); - } - ~SubDevicesScopeGuarded() - { - for (auto &device : sub_devices) - { - cl_int err = clReleaseDevice(device); - if (err != CL_SUCCESS) - log_error("\n Releasing sub-device failed \n"); - } - } - - std::vector sub_devices; -}; - struct SemaphoreBase { SemaphoreBase(cl_device_id device): device(device) {} diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp index 1ec7a551..e3351cd8 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp @@ -381,43 +381,36 @@ struct SemaphoreMultiWait : public SemaphoreTestBase } // anonymous namespace // Confirm that a signal followed by a wait will complete successfully -int test_semaphores_simple_1(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, int num_elements) +REGISTER_TEST_VERSION(semaphores_simple_1, Version(1, 2)) { - return MakeAndRunTest(deviceID, context, defaultQueue, + return MakeAndRunTest(device, context, queue, num_elements); } // Confirm that signal a semaphore with no event dependencies will not result // in an implicit dependency on everything previously submitted -int test_semaphores_simple_2(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, int num_elements) +REGISTER_TEST_VERSION(semaphores_simple_2, Version(1, 2)) { - return MakeAndRunTest(deviceID, context, defaultQueue, + return MakeAndRunTest(device, context, queue, num_elements); } // Confirm that a semaphore can be reused multiple times -int test_semaphores_reuse(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, int num_elements) +REGISTER_TEST_VERSION(semaphores_reuse, Version(1, 2)) { - return MakeAndRunTest(deviceID, context, defaultQueue, - num_elements); + return MakeAndRunTest(device, context, queue, num_elements); } // Confirm that we can signal multiple semaphores with one command -int test_semaphores_multi_signal(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_multi_signal, Version(1, 2)) { - return MakeAndRunTest(deviceID, context, defaultQueue, + return MakeAndRunTest(device, context, queue, num_elements); } // Confirm that we can wait for multiple semaphores with one command -int test_semaphores_multi_wait(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, int num_elements) +REGISTER_TEST_VERSION(semaphores_multi_wait, Version(1, 2)) { - return MakeAndRunTest(deviceID, context, defaultQueue, + return MakeAndRunTest(device, context, queue, num_elements); } diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_cross_queue.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_cross_queue.cpp index 4067fd4e..33c64a96 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_cross_queue.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_cross_queue.cpp @@ -312,41 +312,31 @@ struct SemaphoreOutOfOrderOps : public SemaphoreTestBase } // anonymous namespace // Confirm that a semaphore works across different ooo queues -int test_semaphores_cross_queues_ooo(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_cross_queues_ooo, Version(1, 2)) { - return MakeAndRunTest>( - deviceID, context, defaultQueue, num_elements); + return MakeAndRunTest>(device, context, queue, + num_elements); } // Confirm that a semaphore works across different in-order queues -int test_semaphores_cross_queues_io(cl_device_id deviceID, cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_cross_queues_io, Version(1, 2)) { - return MakeAndRunTest>( - deviceID, context, defaultQueue, num_elements); + return MakeAndRunTest>(device, context, queue, + num_elements); } // Confirm that we can synchronize signal/wait commands in single out-of-order // queue -int test_semaphores_ooo_ops_single_queue(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_ooo_ops_single_queue, Version(1, 2)) { - return MakeAndRunTest>( - deviceID, context, defaultQueue, num_elements); + return MakeAndRunTest>(device, context, queue, + num_elements); } // Confirm that we can synchronize signal/wait commands across two out-of-order // queues -int test_semaphores_ooo_ops_cross_queue(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_ooo_ops_cross_queue, Version(1, 2)) { - return MakeAndRunTest>( - deviceID, context, defaultQueue, num_elements); + return MakeAndRunTest>(device, context, queue, + num_elements); } diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_create.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_create.cpp index 566e5e16..cd50eb4f 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_create.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_create.cpp @@ -17,6 +17,7 @@ #include "semaphore_base.h" #include "harness/errorHelpers.h" +#include #include #include #include @@ -137,38 +138,77 @@ struct CreateInvalidMultiDeviceProperty : public SemaphoreTestBase cl_int Run() override { // partition device and create new context if possible - cl_uint maxComputeUnits = 0; - cl_int err = - clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, - sizeof(maxComputeUnits), &maxComputeUnits, NULL); - test_error(err, "Unable to get maximal number of compute units"); + size_t size = 0; - cl_device_partition_property partitionProp[] = { - CL_DEVICE_PARTITION_EQUALLY, - static_cast(maxComputeUnits / 2), 0 - }; + // query multi-device context and perform objects comparability test + cl_int err = clGetDeviceInfo(device, CL_DEVICE_PARTITION_PROPERTIES, 0, + nullptr, &size); + test_error_fail(err, "clGetDeviceInfo failed"); - cl_uint deviceCount = 0; - // how many sub-devices can we create? - err = - clCreateSubDevices(device, partitionProp, 0, nullptr, &deviceCount); - if (err != CL_SUCCESS) + if ((size / sizeof(cl_device_partition_property)) == 0) { log_info("Can't partition device, test not supported\n"); return TEST_SKIPPED_ITSELF; } - if (deviceCount < 2) - test_error_ret( - CL_INVALID_VALUE, - "Multi context test for CL_INVALID_PROPERTY not supported", - TEST_SKIPPED_ITSELF); + std::vector supported_props( + size / sizeof(cl_device_partition_property), 0); + err = clGetDeviceInfo(device, CL_DEVICE_PARTITION_PROPERTIES, + supported_props.size() + * sizeof(cl_device_partition_property), + supported_props.data(), nullptr); + test_error_fail(err, "clGetDeviceInfo failed"); - // get the list of subDevices - SubDevicesScopeGuarded scope_guard(deviceCount); - err = clCreateSubDevices(device, partitionProp, deviceCount, - scope_guard.sub_devices.data(), &deviceCount); - if (err != CL_SUCCESS) + if (supported_props.front() == 0) + { + log_info("Can't partition device, test not supported\n"); + return TEST_SKIPPED_ITSELF; + } + + cl_uint maxComputeUnits = 0; + err = + clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, + sizeof(maxComputeUnits), &maxComputeUnits, nullptr); + test_error_ret(err, "Unable to get maximal number of compute units", + TEST_FAIL); + + std::vector> + partition_props = { + { CL_DEVICE_PARTITION_EQUALLY, (cl_int)maxComputeUnits / 2, 0, + 0, 0 }, + { CL_DEVICE_PARTITION_BY_COUNTS, 1, (cl_int)maxComputeUnits - 1, + CL_DEVICE_PARTITION_BY_COUNTS_LIST_END, 0 }, + { CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN, + CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE, 0, 0, 0 } + }; + + std::unique_ptr scope_guard; + cl_uint num_devices = 0; + for (auto &sup_prop : supported_props) + { + for (auto &prop : partition_props) + { + if (sup_prop == prop[0]) + { + // how many sub-devices can we create? + err = clCreateSubDevices(device, prop.data(), 0, nullptr, + &num_devices); + test_error_fail(err, "clCreateSubDevices failed"); + if (num_devices < 2) continue; + + // get the list of subDevices + scope_guard.reset(new SubDevicesScopeGuarded(num_devices)); + err = clCreateSubDevices(device, prop.data(), num_devices, + scope_guard->sub_devices.data(), + &num_devices); + test_error_fail(err, "clCreateSubDevices failed"); + break; + } + } + if (scope_guard.get() != nullptr) break; + } + + if (scope_guard.get() == nullptr) { log_info("Can't partition device, test not supported\n"); return TEST_SKIPPED_ITSELF; @@ -176,9 +216,9 @@ struct CreateInvalidMultiDeviceProperty : public SemaphoreTestBase /* Create a multi device context */ clContextWrapper multi_device_context = clCreateContext( - NULL, (cl_uint)deviceCount, scope_guard.sub_devices.data(), nullptr, - nullptr, &err); - test_error_ret(err, "Unable to create testing context", CL_SUCCESS); + NULL, (cl_uint)num_devices, scope_guard->sub_devices.data(), + nullptr, nullptr, &err); + test_error_fail(err, "Unable to create testing context"); cl_semaphore_properties_khr sema_props[] = { (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR, @@ -211,38 +251,77 @@ struct CreateInvalidDevice : public SemaphoreTestBase cl_int Run() override { // create sub devices if possible - cl_uint maxComputeUnits = 0; - int err = - clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, - sizeof(maxComputeUnits), &maxComputeUnits, NULL); - test_error(err, "Unable to get maximal number of compute units"); + size_t size = 0; - cl_device_partition_property partitionProp[] = { - CL_DEVICE_PARTITION_EQUALLY, - static_cast(maxComputeUnits / 2), 0 - }; + // query multi-device context and perform objects comparability test + cl_int err = clGetDeviceInfo(device, CL_DEVICE_PARTITION_PROPERTIES, 0, + nullptr, &size); + test_error_fail(err, "clGetDeviceInfo failed"); - cl_uint deviceCount = 0; - // how many sub-devices can we create? - err = - clCreateSubDevices(device, partitionProp, 0, nullptr, &deviceCount); - if (err != CL_SUCCESS) + if ((size / sizeof(cl_device_partition_property)) == 0) { log_info("Can't partition device, test not supported\n"); return TEST_SKIPPED_ITSELF; } - if (deviceCount < 2) - test_error_ret( - CL_INVALID_VALUE, - "Multi context test for CL_INVALID_PROPERTY not supported", - TEST_SKIPPED_ITSELF); + std::vector supported_props( + size / sizeof(cl_device_partition_property), 0); + err = clGetDeviceInfo(device, CL_DEVICE_PARTITION_PROPERTIES, + supported_props.size() + * sizeof(cl_device_partition_property), + supported_props.data(), nullptr); + test_error_fail(err, "clGetDeviceInfo failed"); - // get the list of subDevices - SubDevicesScopeGuarded scope_guard(deviceCount); - err = clCreateSubDevices(device, partitionProp, deviceCount, - scope_guard.sub_devices.data(), &deviceCount); - if (err != CL_SUCCESS) + if (supported_props.front() == 0) + { + log_info("Can't partition device, test not supported\n"); + return TEST_SKIPPED_ITSELF; + } + + cl_uint maxComputeUnits = 0; + err = + clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, + sizeof(maxComputeUnits), &maxComputeUnits, nullptr); + test_error_ret(err, "Unable to get maximal number of compute units", + TEST_FAIL); + + std::vector> + partition_props = { + { CL_DEVICE_PARTITION_EQUALLY, (cl_int)maxComputeUnits / 2, 0, + 0, 0 }, + { CL_DEVICE_PARTITION_BY_COUNTS, 1, (cl_int)maxComputeUnits - 1, + CL_DEVICE_PARTITION_BY_COUNTS_LIST_END, 0 }, + { CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN, + CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE, 0, 0, 0 } + }; + + std::unique_ptr scope_guard; + cl_uint num_devices = 0; + for (auto &sup_prop : supported_props) + { + for (auto &prop : partition_props) + { + if (sup_prop == prop[0]) + { + // how many sub-devices can we create? + err = clCreateSubDevices(device, prop.data(), 0, nullptr, + &num_devices); + test_error_fail(err, "clCreateSubDevices failed"); + if (num_devices < 2) continue; + + // get the list of subDevices + scope_guard.reset(new SubDevicesScopeGuarded(num_devices)); + err = clCreateSubDevices(device, prop.data(), num_devices, + scope_guard->sub_devices.data(), + &num_devices); + test_error_fail(err, "clCreateSubDevices failed"); + break; + } + } + if (scope_guard.get() != nullptr) break; + } + + if (scope_guard.get() == nullptr) { log_info("Can't partition device, test not supported\n"); return TEST_SKIPPED_ITSELF; @@ -257,7 +336,7 @@ struct CreateInvalidDevice : public SemaphoreTestBase (cl_semaphore_properties_khr) CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR, (cl_semaphore_properties_khr)device, - (cl_semaphore_properties_khr)scope_guard.sub_devices.front(), + (cl_semaphore_properties_khr)scope_guard->sub_devices.front(), (cl_semaphore_properties_khr) CL_SEMAPHORE_DEVICE_HANDLE_LIST_END_KHR, 0 @@ -277,7 +356,7 @@ struct CreateInvalidDevice : public SemaphoreTestBase { /* Create new context with sub-device */ clContextWrapper new_context = clCreateContext( - NULL, (cl_uint)1, scope_guard.sub_devices.data(), nullptr, + NULL, (cl_uint)1, scope_guard->sub_devices.data(), nullptr, nullptr, &err); test_error_ret(err, "Unable to create testing context", CL_SUCCESS); @@ -600,10 +679,7 @@ struct CreateInvalidOperation : public SemaphoreTestBase // Confirm that creation semaphore with nullptr context would return // CL_INVALID_CONTEXT -int test_semaphores_negative_create_invalid_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_invalid_context, Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); @@ -611,10 +687,8 @@ int test_semaphores_negative_create_invalid_context(cl_device_id device, // Confirm that creation semaphore with invalid properties return // CL_INVALID_PROPERTY -int test_semaphores_negative_create_invalid_property(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_invalid_property, + Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); @@ -622,9 +696,8 @@ int test_semaphores_negative_create_invalid_property(cl_device_id device, // Confirm that creation semaphore with multi device property return // CL_INVALID_PROPERTY -int test_semaphores_negative_create_multi_device_property( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_multi_device_property, + Version(1, 2)) { return MakeAndRunTest( device, context, queue, num_elements); @@ -632,10 +705,7 @@ int test_semaphores_negative_create_multi_device_property( // Confirm that creation semaphore with invalid device(s) return // CL_INVALID_DEVICE -int test_semaphores_negative_create_invalid_device(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_invalid_device, Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); @@ -643,9 +713,8 @@ int test_semaphores_negative_create_invalid_device(cl_device_id device, // Confirm that creation semaphore with invalid device(s) return // CL_INVALID_DEVICE -int test_semaphores_negative_create_import_invalid_device( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_import_invalid_device, + Version(1, 2)) { return MakeAndRunTest( device, context, queue, num_elements); @@ -653,10 +722,7 @@ int test_semaphores_negative_create_import_invalid_device( // Confirm that creation semaphore with invalid props values return // CL_INVALID_VALUE -int test_semaphores_negative_create_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_invalid_value, Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); @@ -664,10 +730,8 @@ int test_semaphores_negative_create_invalid_value(cl_device_id device, // Confirm that creation semaphore with invalid props values return // CL_INVALID_VALUE -int test_semaphores_negative_create_invalid_operation(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_create_invalid_operation, + Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_getinfo.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_getinfo.cpp index 155dc84e..0e596c9e 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_getinfo.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_getinfo.cpp @@ -113,19 +113,14 @@ struct GetInfoInvalidValue : public SemaphoreTestBase } -int test_semaphores_negative_get_info_invalid_semaphore(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_get_info_invalid_semaphore, + Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_semaphores_negative_get_info_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_get_info_invalid_value, Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_release_retain.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_release_retain.cpp index 88d7b925..893dd571 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_release_retain.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_release_retain.cpp @@ -76,15 +76,13 @@ struct RetainInvalidSemaphore : public SemaphoreTestBase } -int test_semaphores_negative_release(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_release, Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); } -int test_semaphores_negative_retain(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_retain, Version(1, 2)) { return MakeAndRunTest(device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_wait_signal.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_wait_signal.cpp index 0559abae..8087c703 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_wait_signal.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_wait_signal.cpp @@ -30,26 +30,6 @@ enum class RunMode RM_SIGNAL }; -// scope guard helper to ensure proper releasing of sub devices -struct SubDevicesScopeGuarded -{ - SubDevicesScopeGuarded(const cl_int dev_count) - { - sub_devices.resize(dev_count); - } - ~SubDevicesScopeGuarded() - { - for (auto& device : sub_devices) - { - cl_int err = clReleaseDevice(device); - if (err != CL_SUCCESS) - log_error("\n Releasing sub-device failed \n"); - } - } - - std::vector sub_devices; -}; - // the device associated with command_queue is not same as one of the devices // specified by CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR at the time of creating one // or more of sema_objects. @@ -494,106 +474,80 @@ template struct InvalidEventStatus : public SemaphoreTestBase } -int test_semaphores_negative_wait_invalid_command_queue(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_command_queue, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_wait_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_value, Version(1, 2)) { return MakeAndRunTest>(device, context, queue, num_elements); } -int test_semaphores_negative_wait_invalid_semaphore(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_semaphore, Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_wait_invalid_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_context, Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_wait_invalid_event_wait_list( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_event_wait_list, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_wait_invalid_event_status(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_event_status, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_signal_invalid_command_queue( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_command_queue, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_signal_invalid_value(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_value, Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_signal_invalid_semaphore(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_semaphore, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_signal_invalid_context(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_context, Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_signal_invalid_event_wait_list( - cl_device_id device, cl_context context, cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_event_wait_list, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); } -int test_semaphores_negative_signal_invalid_event_status(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_event_status, + Version(1, 2)) { return MakeAndRunTest>( device, context, queue, num_elements); diff --git a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_queries.cpp b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_queries.cpp index 5f226509..61c1e694 100644 --- a/test_conformance/extensions/cl_khr_semaphore/test_semaphores_queries.cpp +++ b/test_conformance/extensions/cl_khr_semaphore/test_semaphores_queries.cpp @@ -255,32 +255,23 @@ struct SemaphoreMultiDeviceContextQueries : public SemaphoreTestBase } // anonymous namespace // Confirm the semaphore with device list can be successfully queried -int test_semaphores_device_list_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_device_list_queries, Version(1, 2)) { - return MakeAndRunTest( - deviceID, context, defaultQueue, num_elements); + return MakeAndRunTest(device, context, + queue, num_elements); } // Confirm the semaphore without device list can be successfully queried -int test_semaphores_no_device_list_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_no_device_list_queries, Version(1, 2)) { - return MakeAndRunTest( - deviceID, context, defaultQueue, num_elements); + return MakeAndRunTest(device, context, queue, + num_elements); } // Confirm the semaphore created with multi-device context can be successfully // queried -int test_semaphores_multi_device_context_queries(cl_device_id deviceID, - cl_context context, - cl_command_queue defaultQueue, - int num_elements) +REGISTER_TEST_VERSION(semaphores_multi_device_context_queries, Version(1, 2)) { return MakeAndRunTest( - deviceID, context, defaultQueue, num_elements); + device, context, queue, num_elements); } diff --git a/test_conformance/gl/CMakeLists.txt b/test_conformance/gl/CMakeLists.txt index dbabe605..b4adb4d7 100644 --- a/test_conformance/gl/CMakeLists.txt +++ b/test_conformance/gl/CMakeLists.txt @@ -29,6 +29,7 @@ set (${MODULE_NAME}_SOURCES test_renderbuffer.cpp test_renderbuffer_info.cpp test_fence_sync.cpp + test_queries.cpp helpers.cpp ../../test_common/gl/helpers.cpp ) @@ -59,4 +60,4 @@ set_source_files_properties( # folder. include_directories(${CMAKE_CURRENT_SOURCE_DIR}) -include(../CMakeCommon.txt) \ No newline at end of file +include(../CMakeCommon.txt) diff --git a/test_conformance/gl/main.cpp b/test_conformance/gl/main.cpp index e5d6b65d..43df1d19 100644 --- a/test_conformance/gl/main.cpp +++ b/test_conformance/gl/main.cpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2017 The Khronos Group Inc. +// 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. @@ -103,6 +103,8 @@ TEST_FN_REDIRECTOR(renderbuffer_getinfo) TEST_FN_REDIRECTOR(fence_sync) +TEST_FN_REDIRECTOR(queries) + test_definition test_list[] = { TEST_FN_REDIRECT(buffers), TEST_FN_REDIRECT(buffers_getinfo), @@ -132,7 +134,9 @@ test_definition test_list[] = { TEST_FN_REDIRECT(buffers), TEST_FN_REDIRECT(renderbuffer_read), TEST_FN_REDIRECT(renderbuffer_write), - TEST_FN_REDIRECT(renderbuffer_getinfo) }; + TEST_FN_REDIRECT(renderbuffer_getinfo), + + TEST_FN_REDIRECT(queries) }; test_definition test_list32[] = { TEST_FN_REDIRECT(images_read_texturebuffer), diff --git a/test_conformance/gl/procs.h b/test_conformance/gl/procs.h index 111de7a6..738f7c81 100644 --- a/test_conformance/gl/procs.h +++ b/test_conformance/gl/procs.h @@ -1,5 +1,5 @@ // -// Copyright (c) 2017 The Khronos Group Inc. +// 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. @@ -150,4 +150,6 @@ extern int test_image_methods_multisample(cl_device_id device, cl_command_queue queue, int); extern int test_renderbuffer_getinfo(cl_device_id device, cl_context context, - cl_command_queue queue, int numElements); \ No newline at end of file + cl_command_queue queue, int numElements); +extern int test_queries(cl_device_id device, cl_context context, + cl_command_queue queue, int); diff --git a/test_conformance/gl/test_queries.cpp b/test_conformance/gl/test_queries.cpp new file mode 100644 index 00000000..36798ca8 --- /dev/null +++ b/test_conformance/gl/test_queries.cpp @@ -0,0 +1,150 @@ +// +// 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 "common.h" +#include "testBase.h" +#include "gl/setup.h" + +namespace { + +struct FindDeviceFunctor +{ + FindDeviceFunctor() + { + if (init()) throw std::runtime_error("FindDeviceFunctor failed"); + } + + cl_int init() + { + cl_uint num_platforms = 0; + cl_int error = clGetPlatformIDs(0, nullptr, &num_platforms); + test_error(error, "clGetPlatformIDs failed"); + + platforms.resize(num_platforms); + + error = + clGetPlatformIDs(num_platforms, platforms.data(), &num_platforms); + test_error(error, "clGetPlatformIDs failed"); + + return CL_SUCCESS; + } + + bool find(const cl_device_id id) + { + cl_uint num_devices = 0; + for (size_t p = 0; p < platforms.size(); p++) + { + cl_int error = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, 0, + nullptr, &num_devices); + test_error(error, "clGetDeviceIDs failed"); + + std::vector devices(num_devices); + error = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, + num_devices, devices.data(), nullptr); + test_error(error, "clGetDeviceIDs failed"); + + for (auto did : devices) + if (did == id) return false; + } + return true; + } + std::vector platforms; +}; + +} // anonymous namespace + +int test_queries(cl_device_id device, cl_context context, + cl_command_queue queue, int) +{ + // get a platform associated with device id + cl_platform_id platform; + cl_int error = clGetDeviceInfo(device, CL_DEVICE_PLATFORM, + sizeof(cl_platform_id), &platform, NULL); + test_error(error, "clGetDeviceInfo for CL_DEVICE_PLATFORM failed"); + + size_t returned_size = 0; + error = clGetContextInfo(context, CL_CONTEXT_PROPERTIES, 0, nullptr, + &returned_size); + test_error(error, "clGetContextInfo failed"); + + std::vector props( + returned_size / sizeof(cl_context_properties), 0); + + error = clGetContextInfo(context, CL_CONTEXT_PROPERTIES, + sizeof(cl_context_properties) * props.size(), + props.data(), nullptr); + test_error(error, "clGetContextInfo failed"); + + // get GL context info function pointer + size_t dev_size = 0; + clGetGLContextInfoKHR_fn clGetGLContextInfoKHR = + (clGetGLContextInfoKHR_fn)clGetExtensionFunctionAddressForPlatform( + platform, "clGetGLContextInfoKHR"); + + test_assert_error(clGetGLContextInfoKHR != NULL, + "unable to get the function pointer for " + "clGetGLContextInfoKHR\n"); + + // get the size of all GL interop capable devices + error = clGetGLContextInfoKHR(props.data(), CL_DEVICES_FOR_GL_CONTEXT_KHR, + 0, nullptr, &dev_size); + test_error(error, + "clGetGLContextInfoKHR(CL_DEVICES_FOR_GL_CONTEXT_KHR) failed"); + + dev_size /= sizeof(cl_device_id); + log_info("GL _context supports %zu compute devices\n", dev_size); + + + // get all GL interop capable devices + std::vector devices(dev_size, 0); + error = clGetGLContextInfoKHR(props.data(), CL_DEVICES_FOR_GL_CONTEXT_KHR, + devices.size() * sizeof(cl_device_id), + devices.data(), &dev_size); + test_error(error, + "clGetGLContextInfoKHR(CL_DEVICES_FOR_GL_CONTEXT_KHR) failed"); + if (devices.size() != dev_size / sizeof(cl_device_id)) + { + log_error("unexpected clGetGLContextInfoKHR result"); + return TEST_FAIL; + } + + // comparability test for CL_DEVICES_FOR_GL_CONTEXT_KHR + FindDeviceFunctor fdf; + for (auto &did : devices) + if (fdf.find(did) != 0) return TEST_FAIL; + + // get current device associated with GL environment + error = clGetGLContextInfoKHR( + props.data(), CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, + devices.size() * sizeof(cl_device_id), devices.data(), &dev_size); + test_error( + error, + "clGetGLContextInfoKHR(CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR) failed"); + + // verify if CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR query result with only one + // device + if (dev_size != sizeof(cl_device_id)) + { + log_info("GL _context current device is not a CL device.\n"); + return TEST_FAIL; + } + + // comparability test for CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR + test_assert_error(device == devices[0], + "Unexpected result returned by clGetGLContextInfo for " + "CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR query"); + + return TEST_PASS; +} diff --git a/test_conformance/images/clCopyImage/main.cpp b/test_conformance/images/clCopyImage/main.cpp index 5526c398..2ad701b1 100644 --- a/test_conformance/images/clCopyImage/main.cpp +++ b/test_conformance/images/clCopyImage/main.cpp @@ -33,76 +33,54 @@ extern int test_image_set( cl_device_id device, cl_context context, cl_command_q static void printUsage( const char *execName ); -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) -{ - return test_image_set( device, context, queue, k1D ); -} -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) -{ - return test_image_set( device, context, queue, k2D ); -} -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) -{ - return test_image_set( device, context, queue, k3D ); -} -int test_1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return test_image_set(device, context, queue, k1D); } +REGISTER_TEST(2D) { return test_image_set(device, context, queue, k2D); } +REGISTER_TEST(3D) { return test_image_set(device, context, queue, k3D); } +REGISTER_TEST(1Dbuffer) { return test_image_set(device, context, queue, k1DBuffer); } -int test_1DTo1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1DTo1Dbuffer) { return test_image_set(device, context, queue, k1DTo1DBuffer); } -int test_1DbufferTo1D(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1DbufferTo1D) { return test_image_set(device, context, queue, k1DBufferTo1D); } -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1Darray) { return test_image_set( device, context, queue, k1DArray ); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return test_image_set( device, context, queue, k2DArray ); } -int test_2Dto3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Dto3D) { return test_image_set( device, context, queue, k2DTo3D ); } -int test_3Dto2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3Dto2D) { return test_image_set( device, context, queue, k3DTo2D ); } -int test_2Darrayto2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darrayto2D) { return test_image_set( device, context, queue, k2DArrayTo2D ); } -int test_2Dto2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Dto2Darray) { return test_image_set( device, context, queue, k2DTo2DArray ); } -int test_2Darrayto3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darrayto3D) { return test_image_set( device, context, queue, k2DArrayTo3D ); } -int test_3Dto2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3Dto2Darray) { return test_image_set( device, context, queue, k3DTo2DArray ); } -test_definition test_list[] = { - ADD_TEST(1D), ADD_TEST(2D), ADD_TEST(3D), - ADD_TEST(1Darray), ADD_TEST(2Darray), ADD_TEST(2Dto3D), - ADD_TEST(3Dto2D), ADD_TEST(2Darrayto2D), ADD_TEST(2Dto2Darray), - ADD_TEST(2Darrayto3D), ADD_TEST(3Dto2Darray), ADD_TEST(1Dbuffer), - ADD_TEST(1DTo1Dbuffer), ADD_TEST(1DbufferTo1D), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -160,8 +138,10 @@ int main(int argc, const char *argv[]) if( gTestSmallImages ) log_info( "Note: Using small test images\n" ); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); free(argList); return ret; @@ -183,8 +163,8 @@ static void printUsage( const char *execName ) log_info( "\tuse_pitches - Enables row and slice pitches\n" ); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } } diff --git a/test_conformance/images/clCopyImage/test_copy_1D.cpp b/test_conformance/images/clCopyImage/test_copy_1D.cpp index 7d13eaab..9d075ac0 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D.cpp @@ -18,32 +18,41 @@ extern int test_copy_image_generic( cl_context context, cl_command_queue queue, image_descriptor *srcImageInfo, image_descriptor *dstImageInfo, const size_t sourcePos[], const size_t destPos[], const size_t regionSize[], MTdata d ); -int test_copy_image_size_1D( cl_context context, cl_command_queue queue, image_descriptor *imageInfo, MTdata d ) +int test_copy_image_size_1D(cl_context context, cl_command_queue queue, + image_descriptor *srcImageInfo, + image_descriptor *dstImageInfo, MTdata d) { size_t sourcePos[ 3 ], destPos[ 3 ], regionSize[ 3 ]; int ret = 0, retCode; - size_t src_lod = 0, src_width_lod = imageInfo->width, src_row_pitch_lod; - size_t dst_lod = 0, dst_width_lod = imageInfo->width, dst_row_pitch_lod; - size_t width_lod = imageInfo->width; - size_t max_mip_level = 0; + size_t src_lod = 0, src_width_lod = srcImageInfo->width, src_row_pitch_lod; + size_t dst_lod = 0, dst_width_lod = srcImageInfo->width, dst_row_pitch_lod; + size_t width_lod = srcImageInfo->width; + size_t max_mip_level = 0; - if( gTestMipmaps ) - { - max_mip_level = imageInfo->num_mip_levels; - // Work at a random mip level - src_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - dst_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; - width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; - src_row_pitch_lod = src_width_lod * get_pixel_size( imageInfo->format ); - dst_row_pitch_lod = dst_width_lod * get_pixel_size( imageInfo->format ); - } + if (gTestMipmaps) + { + max_mip_level = srcImageInfo->num_mip_levels; + // Work at a random mip level + src_lod = + (size_t)random_in_range(0, max_mip_level ? max_mip_level - 1 : 0, d); + dst_lod = + (size_t)random_in_range(0, max_mip_level ? max_mip_level - 1 : 0, d); + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; + width_lod = + (src_width_lod > dst_width_lod) ? dst_width_lod : src_width_lod; + src_row_pitch_lod = src_width_lod * get_pixel_size(srcImageInfo->format); + dst_row_pitch_lod = dst_width_lod * get_pixel_size(dstImageInfo->format); + } // First, try just a full covering region sourcePos[ 0 ] = sourcePos[ 1 ] = sourcePos[ 2 ] = 0; destPos[ 0 ] = destPos[ 1 ] = destPos[ 2 ] = 0; - regionSize[ 0 ] = imageInfo->width; + regionSize[0] = dstImageInfo->width; regionSize[ 1 ] = 1; regionSize[ 2 ] = 1; @@ -54,7 +63,9 @@ int test_copy_image_size_1D( cl_context context, cl_command_queue queue, image_d regionSize[ 0 ] = width_lod; } - retCode = test_copy_image_generic( context, queue, imageInfo, imageInfo, sourcePos, destPos, regionSize, d ); + retCode = + test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + sourcePos, destPos, regionSize, d); if( retCode < 0 ) return retCode; else @@ -68,8 +79,12 @@ int test_copy_image_size_1D( cl_context context, cl_command_queue queue, image_d // Work at a random mip level src_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); dst_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; sourcePos[ 1 ] = src_lod; destPos[ 1 ] = dst_lod; @@ -83,7 +98,9 @@ int test_copy_image_size_1D( cl_context context, cl_command_queue queue, image_d // Go for it! - retCode = test_copy_image_generic( context, queue, imageInfo, imageInfo, sourcePos, destPos, regionSize, d ); + retCode = + test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + sourcePos, destPos, regionSize, d); if( retCode < 0 ) return retCode; else @@ -93,18 +110,25 @@ int test_copy_image_size_1D( cl_context context, cl_command_queue queue, image_d return ret; } -int test_copy_image_set_1D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ) +int test_copy_image_set_1D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) { + assert(dst_type == src_type); // This test expects to copy 1D -> 1D images size_t maxWidth; cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; RandomSeed seed(gRandomSeed); size_t pixelSize; - imageInfo.format = format; - imageInfo.height = imageInfo.depth = imageInfo.arraySize = imageInfo.slicePitch = 0; - imageInfo.type = CL_MEM_OBJECT_IMAGE1D; - pixelSize = get_pixel_size( imageInfo.format ); + srcImageInfo.format = format; + srcImageInfo.height = srcImageInfo.depth = srcImageInfo.arraySize = + srcImageInfo.slicePitch = 0; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL ); @@ -118,28 +142,33 @@ int test_copy_image_set_1D( cl_device_id device, cl_context context, cl_command_ if( gTestSmallImages ) { - for( imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++ ) + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), seed); + if (gTestMipmaps) + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(srcImageInfo.width, 0, 0), seed); - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - if( gDebugTrace ) - log_info( " at size %d\n", (int)imageInfo.width ); + if (gDebugTrace) log_info(" at size %d\n", (int)srcImageInfo.width); - int ret = test_copy_image_size_1D( context, queue, &imageInfo, seed ); - if( ret ) - return -1; + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_1D(context, queue, &srcImageInfo, + &dstImageInfo, seed); + if (ret) return -1; } } else if( gTestMaxImages ) @@ -148,29 +177,37 @@ int test_copy_image_set_1D( cl_device_id device, cl_context context, cl_command_ size_t numbeOfSizes; size_t sizes[100][3]; - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1, maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D, imageInfo.format); + get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1, + maxAllocSize, memSize, src_type, srcImageInfo.format); for( size_t idx = 0; idx < numbeOfSizes; idx++ ) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.width = sizes[ idx ][ 0 ]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), seed); + if (gTestMipmaps) + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(srcImageInfo.width, 0, 0), seed); - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } log_info( "Testing %d\n", (int)sizes[ idx ][ 0 ] ); if( gDebugTrace ) log_info( " at max size %d\n", (int)sizes[ idx ][ 0 ] ); - if( test_copy_image_size_1D( context, queue, &imageInfo, seed ) ) + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + if (test_copy_image_size_1D(context, queue, &srcImageInfo, + &dstImageInfo, seed)) return -1; } } @@ -184,41 +221,52 @@ int test_copy_image_set_1D( cl_device_id device, cl_context context, cl_command_ // image, the result array, plus offset arrays, will fit in the global ram space do { - imageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); + srcImageInfo.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); - if (gTestMipmaps) - { - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), seed); - imageInfo.rowPitch = imageInfo.width * get_pixel_size( imageInfo.format ); - size = compute_mipmapped_image_size( imageInfo ); - size = size*4; - } + if (gTestMipmaps) + { + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, 0, 0), + seed); + srcImageInfo.rowPitch = srcImageInfo.width + * get_pixel_size(srcImageInfo.format); + size = compute_mipmapped_image_size(srcImageInfo); + size = size * 4; + } else { - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - size = (size_t)imageInfo.rowPitch * 4; + size = (size_t)srcImageInfo.rowPitch * 4; } } while( size > maxAllocSize || ( size * 3 ) > memSize ); if( gDebugTrace ) { - log_info( " at size %d (row pitch %d) out of %d\n", (int)imageInfo.width, (int)imageInfo.rowPitch, (int)maxWidth ); - if ( gTestMipmaps ) - log_info(" and %u mip levels\n", imageInfo.num_mip_levels); + log_info(" at size %d (row pitch %d) out of %d\n", + (int)srcImageInfo.width, (int)srcImageInfo.rowPitch, + (int)maxWidth); + if (gTestMipmaps) + log_info(" and %zu mip levels\n", + (size_t)srcImageInfo.num_mip_levels); } - - int ret = test_copy_image_size_1D( context, queue, &imageInfo, seed ); - if( ret ) - return -1; + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_1D(context, queue, &srcImageInfo, + &dstImageInfo, seed); + if (ret) return -1; } } diff --git a/test_conformance/images/clCopyImage/test_copy_1D_array.cpp b/test_conformance/images/clCopyImage/test_copy_1D_array.cpp index d94ba8ef..78ab903e 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D_array.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D_array.cpp @@ -18,33 +18,41 @@ extern int test_copy_image_generic( cl_context context, cl_command_queue queue, image_descriptor *srcImageInfo, image_descriptor *dstImageInfo, const size_t sourcePos[], const size_t destPos[], const size_t regionSize[], MTdata d ); -int test_copy_image_size_1D_array( cl_context context, cl_command_queue queue, image_descriptor *imageInfo, MTdata d ) +int test_copy_image_size_1D_array(cl_context context, cl_command_queue queue, + image_descriptor *srcImageInfo, + image_descriptor *dstImageInfo, MTdata d) { size_t sourcePos[ 3 ], destPos[ 3 ], regionSize[ 3 ]; int ret = 0, retCode; - size_t src_lod = 0, src_width_lod = imageInfo->width, src_row_pitch_lod; - size_t dst_lod = 0, dst_width_lod = imageInfo->width, dst_row_pitch_lod; - size_t width_lod = imageInfo->width; + size_t src_lod = 0, src_width_lod = srcImageInfo->width, src_row_pitch_lod; + size_t dst_lod = 0, dst_width_lod = dstImageInfo->width, dst_row_pitch_lod; + size_t width_lod = srcImageInfo->width; size_t max_mip_level = 0; if( gTestMipmaps ) { - max_mip_level = imageInfo->num_mip_levels; + max_mip_level = srcImageInfo->num_mip_levels; // Work at a random mip level src_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); dst_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; - src_row_pitch_lod = src_width_lod * get_pixel_size( imageInfo->format ); - dst_row_pitch_lod = dst_width_lod * get_pixel_size( imageInfo->format ); + src_row_pitch_lod = + src_width_lod * get_pixel_size(srcImageInfo->format); + dst_row_pitch_lod = + dst_width_lod * get_pixel_size(dstImageInfo->format); } // First, try just a full covering region sourcePos[ 0 ] = sourcePos[ 1 ] = sourcePos[ 2 ] = 0; destPos[ 0 ] = destPos[ 1 ] = destPos[ 2 ] = 0; - regionSize[ 0 ] = imageInfo->width; - regionSize[ 1 ] = imageInfo->arraySize; + regionSize[0] = srcImageInfo->width; + regionSize[1] = srcImageInfo->arraySize; regionSize[ 2 ] = 1; if(gTestMipmaps) @@ -54,7 +62,9 @@ int test_copy_image_size_1D_array( cl_context context, cl_command_queue queue, i regionSize[ 0 ] = width_lod; } - retCode = test_copy_image_generic( context, queue, imageInfo, imageInfo, sourcePos, destPos, regionSize, d ); + retCode = + test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + sourcePos, destPos, regionSize, d); if( retCode < 0 ) return retCode; else @@ -68,27 +78,41 @@ int test_copy_image_size_1D_array( cl_context context, cl_command_queue queue, i // Work at a random mip level src_lod = (size_t) ( max_mip_level > 1 )? random_in_range( 0, max_mip_level - 1 , d ) : 0; dst_lod = (size_t) ( max_mip_level > 1 )? random_in_range( 0, max_mip_level - 1 , d ) : 0; - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; sourcePos[ 2 ] = src_lod; destPos[ 2 ] = dst_lod; } // Pick a random size regionSize[ 0 ] = ( width_lod > 8 ) ? (size_t)random_in_range( 8, (int)width_lod - 1, d ) : (int)width_lod; - regionSize[ 1 ] = ( imageInfo->arraySize > 8 ) ? (size_t)random_in_range( 8, (int)imageInfo->arraySize - 1, d ) : imageInfo->arraySize; + regionSize[1] = (srcImageInfo->arraySize > 8) + ? (size_t)random_in_range(8, (int)srcImageInfo->arraySize - 1, d) + : srcImageInfo->arraySize; // Now pick positions within valid ranges sourcePos[ 0 ] = ( width_lod > regionSize[ 0 ] ) ? (size_t)random_in_range( 0, (int)( width_lod - regionSize[ 0 ] - 1 ), d ) : 0; - sourcePos[ 1 ] = ( imageInfo->arraySize > regionSize[ 1 ] ) ? (size_t)random_in_range( 0, (int)( imageInfo->arraySize - regionSize[ 1 ] - 1 ), d ) : 0; + sourcePos[1] = (srcImageInfo->arraySize > regionSize[1]) + ? (size_t)random_in_range( + 0, (int)(srcImageInfo->arraySize - regionSize[1] - 1), d) + : 0; destPos[ 0 ] = ( width_lod > regionSize[ 0 ] ) ? (size_t)random_in_range( 0, (int)( width_lod - regionSize[ 0 ] - 1 ), d ) : 0; - destPos[ 1 ] = ( imageInfo->arraySize > regionSize[ 1 ] ) ? (size_t)random_in_range( 0, (int)( imageInfo->arraySize - regionSize[ 1 ] - 1 ), d ) : 0; + destPos[1] = (dstImageInfo->arraySize > regionSize[1]) + ? (size_t)random_in_range( + 0, (int)(dstImageInfo->arraySize - regionSize[1] - 1), d) + : 0; // Go for it! - retCode = test_copy_image_generic( context, queue, imageInfo, imageInfo, sourcePos, destPos, regionSize, d ); + retCode = + test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + sourcePos, destPos, regionSize, d); if( retCode < 0 ) return retCode; else @@ -98,17 +122,27 @@ int test_copy_image_size_1D_array( cl_context context, cl_command_queue queue, i return ret; } -int test_copy_image_set_1D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ) +int test_copy_image_set_1D_array(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, + cl_mem_flags dst_flags, + cl_mem_object_type dst_type, + cl_image_format *format) { + assert( + dst_type + == src_type); // This test expects to copy 1D array -> 1D array images size_t maxWidth, maxArraySize; cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; RandomSeed seed(gRandomSeed); size_t pixelSize; - imageInfo.format = format; - imageInfo.type = CL_MEM_OBJECT_IMAGE1D_ARRAY; - pixelSize = get_pixel_size( imageInfo.format ); + srcImageInfo.format = format; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof( maxArraySize ), &maxArraySize, NULL ); @@ -123,33 +157,41 @@ int test_copy_image_set_1D_array( cl_device_id device, cl_context context, cl_co if( gTestSmallImages ) { - for( imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++ ) + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), seed); + if (gTestMipmaps) + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(srcImageInfo.width, 0, 0), seed); - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - imageInfo.slicePitch = imageInfo.rowPitch; - for( imageInfo.arraySize = 2; imageInfo.arraySize < 9; imageInfo.arraySize++ ) - { - if( gDebugTrace ) - log_info( " at size %d,%d\n", (int)imageInfo.width, (int)imageInfo.arraySize ); + srcImageInfo.slicePitch = srcImageInfo.rowPitch; + for (srcImageInfo.arraySize = 2; srcImageInfo.arraySize < 9; + srcImageInfo.arraySize++) + { + if (gDebugTrace) + log_info(" at size %d,%d\n", (int)srcImageInfo.width, + (int)srcImageInfo.arraySize); - int ret = test_copy_image_size_1D_array( context, queue, &imageInfo, seed ); - if( ret ) - return -1; - } + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_1D_array(context, queue, &srcImageInfo, + &dstImageInfo, seed); + if (ret) return -1; + } } } else if( gTestMaxImages ) @@ -158,33 +200,42 @@ int test_copy_image_set_1D_array( cl_device_id device, cl_context context, cl_co size_t numbeOfSizes; size_t sizes[100][3]; - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, maxArraySize, maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_ARRAY, imageInfo.format); + get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, maxArraySize, + maxAllocSize, memSize, src_type, srcImageInfo.format); for( size_t idx = 0; idx < numbeOfSizes; idx++ ) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.width = sizes[ idx ][ 0 ]; - imageInfo.arraySize = sizes[ idx ][ 2 ]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.arraySize = sizes[idx][2]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), seed); + if (gTestMipmaps) + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, (int)compute_max_mip_levels(srcImageInfo.width, 0, 0), seed); - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - imageInfo.slicePitch = imageInfo.rowPitch; - log_info( "Testing %d x %d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 2 ] ); - if( gDebugTrace ) - log_info( " at max size %d,%d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 2 ] ); - if( test_copy_image_size_1D_array( context, queue, &imageInfo, seed ) ) - return -1; + srcImageInfo.slicePitch = srcImageInfo.rowPitch; + log_info("Testing %d x %d\n", (int)sizes[idx][0], (int)sizes[idx][2]); + if (gDebugTrace) + log_info(" at max size %d,%d\n", (int)sizes[idx][0], + (int)sizes[idx][2]); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + if (test_copy_image_size_1D_array(context, queue, &srcImageInfo, + &dstImageInfo, seed)) + return -1; } } else @@ -197,39 +248,55 @@ int test_copy_image_set_1D_array( cl_device_id device, cl_context context, cl_co // image, the result array, plus offset arrays, will fit in the global ram space do { - imageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - imageInfo.arraySize = (size_t)random_log_in_range( 16, (int)maxArraySize / 32, seed ); - imageInfo.height = imageInfo.depth = 0; + srcImageInfo.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + srcImageInfo.arraySize = (size_t)random_log_in_range( + 16, (int)maxArraySize / 32, seed); + srcImageInfo.height = srcImageInfo.depth = 0; - if (gTestMipmaps) - { - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, 0, 0), seed); - imageInfo.rowPitch = imageInfo.width * get_pixel_size( imageInfo.format ); - imageInfo.slicePitch = imageInfo.rowPitch; - size = compute_mipmapped_image_size( imageInfo ); - size = size*4; - } + if (gTestMipmaps) + { + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, 0, 0), + seed); + srcImageInfo.rowPitch = srcImageInfo.width + * get_pixel_size(srcImageInfo.format); + srcImageInfo.slicePitch = srcImageInfo.rowPitch; + size = compute_mipmapped_image_size(srcImageInfo); + size = size * 4; + } else { - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - imageInfo.slicePitch = imageInfo.rowPitch; + srcImageInfo.slicePitch = srcImageInfo.rowPitch; - size = (size_t)imageInfo.rowPitch * (size_t)imageInfo.arraySize * 4; + size = (size_t)srcImageInfo.rowPitch + * (size_t)srcImageInfo.arraySize * 4; } } while( size > maxAllocSize || ( size * 3 ) > memSize ); if( gDebugTrace ) - log_info( " at size %d,%d (row pitch %d) out of %d,%d\n", (int)imageInfo.width, (int)imageInfo.arraySize, (int)imageInfo.rowPitch, (int)maxWidth, (int)maxArraySize ); - int ret = test_copy_image_size_1D_array( context, queue, &imageInfo, seed ); + log_info(" at size %d,%d (row pitch %d) out of %d,%d\n", + (int)srcImageInfo.width, (int)srcImageInfo.arraySize, + (int)srcImageInfo.rowPitch, (int)maxWidth, + (int)maxArraySize); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_1D_array(context, queue, &srcImageInfo, + &dstImageInfo, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp index f74e60a9..07c86ccc 100644 --- a/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp +++ b/test_conformance/images/clCopyImage/test_copy_1D_buffer.cpp @@ -75,13 +75,18 @@ int test_copy_image_size_1D_buffer(cl_context context, cl_command_queue queue, return ret; } -int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, - cl_image_format *format) +int test_copy_image_set_1D_buffer( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) { + assert( + dst_type + == src_type); // This test expects to copy 1D buffer -> 1D buffer images size_t maxWidth; cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; RandomSeed seed(gRandomSeed); size_t pixelSize; @@ -92,11 +97,12 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, return 0; } - imageInfo.format = format; - imageInfo.height = imageInfo.depth = imageInfo.arraySize = - imageInfo.slicePitch = 0; - imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; - pixelSize = get_pixel_size(imageInfo.format); + srcImageInfo.format = format; + srcImageInfo.height = srcImageInfo.depth = srcImageInfo.arraySize = + srcImageInfo.slicePitch = 0; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, sizeof(maxWidth), &maxWidth, NULL); @@ -114,168 +120,29 @@ int test_copy_image_set_1D_buffer(cl_device_id device, cl_context context, if (gTestSmallImages) { - for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++) + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } - if (gDebugTrace) log_info(" at size %d\n", (int)imageInfo.width); - - int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo, - &imageInfo, seed); - if (ret) return -1; - } - } - else if (gTestMaxImages) - { - // Try a specific set of maximum sizes - size_t numbeOfSizes; - size_t sizes[100][3]; - - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1, - maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_BUFFER, - imageInfo.format); - - for (size_t idx = 0; idx < numbeOfSizes; idx++) - { - size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.width = sizes[idx][0]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - - if (gEnablePitch) - { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - log_info("Testing %d\n", (int)sizes[idx][0]); - if (gDebugTrace) - log_info(" at max size %d\n", (int)sizes[idx][0]); - if (test_copy_image_size_1D_buffer(context, queue, &imageInfo, - &imageInfo, seed)) - return -1; - } - } - else - { - for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++) - { - cl_ulong size; - size_t rowPadding = gEnablePitch ? 48 : 0; - // Loop until we get a size that a) will fit in the max alloc size - // and b) that an allocation of that image, the result array, plus - // offset arrays, will fit in the global ram space - do - { - imageInfo.width = - (size_t)random_log_in_range(16, (int)(maxWidth / 32), seed); - - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - - if (gEnablePitch) - { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - size = (size_t)imageInfo.rowPitch * 4; - } while (size > maxAllocSize || (size * 3) > memSize); - if (gDebugTrace) - { - log_info(" at size %d (row pitch %d) out of %d\n", - (int)imageInfo.width, (int)imageInfo.rowPitch, - (int)maxWidth); - } - - int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo, - &imageInfo, seed); - if (ret) return -1; - } - } - - return 0; -} - -int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, - cl_command_queue queue, - cl_image_format *format) -{ - size_t maxWidth; - cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; - RandomSeed seed(gRandomSeed); - size_t pixelSize; - - if (gTestMipmaps) - { - // 1D image buffers don't support mipmaps - // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#cl_khr_mipmap_image - return 0; - } - - imageInfo.format = format; - imageInfo.height = imageInfo.depth = imageInfo.arraySize = - imageInfo.slicePitch = 0; - imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; - pixelSize = get_pixel_size(imageInfo.format); - - int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH, - sizeof(maxWidth), &maxWidth, NULL); - error |= clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, - sizeof(maxAllocSize), &maxAllocSize, NULL); - error |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize), - &memSize, NULL); - test_error(error, "Unable to get max image 1D buffer size from device"); - - if (memSize > (cl_ulong)SIZE_MAX) - { - memSize = (cl_ulong)SIZE_MAX; - maxAllocSize = (cl_ulong)SIZE_MAX; - } - - if (gTestSmallImages) - { - for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++) - { - size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - - if (gEnablePitch) - { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - if (gDebugTrace) log_info(" at size %d\n", (int)imageInfo.width); - - image_descriptor srcImageInfo = imageInfo; - srcImageInfo.type = CL_MEM_OBJECT_IMAGE1D; + log_info(" at size %d\n", (int)srcImageInfo.width); + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; int ret = test_copy_image_size_1D_buffer( - context, queue, &srcImageInfo, &imageInfo, seed); + context, queue, &srcImageInfo, &dstImageInfo, seed); if (ret) return -1; } } @@ -286,183 +153,31 @@ int test_copy_image_set_1D_1D_buffer(cl_device_id device, cl_context context, size_t sizes[100][3]; get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1, - maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_BUFFER, - imageInfo.format); + maxAllocSize, memSize, src_type, srcImageInfo.format); for (size_t idx = 0; idx < numbeOfSizes; idx++) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.width = sizes[idx][0]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } log_info("Testing %d\n", (int)sizes[idx][0]); if (gDebugTrace) log_info(" at max size %d\n", (int)sizes[idx][0]); - image_descriptor srcImageInfo = imageInfo; - srcImageInfo.type = CL_MEM_OBJECT_IMAGE1D; - + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; if (test_copy_image_size_1D_buffer(context, queue, &srcImageInfo, - &imageInfo, seed)) - return -1; - } - } - else - { - for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++) - { - cl_ulong size; - size_t rowPadding = gEnablePitch ? 48 : 0; - // Loop until we get a size that a) will fit in the max alloc size - // and b) that an allocation of that image, the result array, plus - // offset arrays, will fit in the global ram space - do - { - imageInfo.width = - (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); - - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - - if (gEnablePitch) - { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - size = (size_t)imageInfo.rowPitch * 4; - } while (size > maxAllocSize || (size * 3) > memSize); - - if (gDebugTrace) - { - log_info(" at size %d (row pitch %d) out of %d\n", - (int)imageInfo.width, (int)imageInfo.rowPitch, - (int)maxWidth); - } - - image_descriptor srcImageInfo = imageInfo; - srcImageInfo.type = CL_MEM_OBJECT_IMAGE1D; - - int ret = test_copy_image_size_1D_buffer( - context, queue, &srcImageInfo, &imageInfo, seed); - if (ret) return -1; - } - } - - return 0; -} - -int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, - cl_command_queue queue, - cl_image_format *format) -{ - size_t maxWidth; - cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; - RandomSeed seed(gRandomSeed); - size_t pixelSize; - - if (gTestMipmaps) - { - // 1D image buffers don't support mipmaps - // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#cl_khr_mipmap_image - return 0; - } - - imageInfo.format = format; - imageInfo.height = imageInfo.depth = imageInfo.arraySize = - imageInfo.slicePitch = 0; - imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; - pixelSize = get_pixel_size(imageInfo.format); - - int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH, - sizeof(maxWidth), &maxWidth, NULL); - error |= clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, - sizeof(maxAllocSize), &maxAllocSize, NULL); - error |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize), - &memSize, NULL); - test_error(error, "Unable to get max image 1D buffer size from device"); - - if (memSize > (cl_ulong)SIZE_MAX) - { - memSize = (cl_ulong)SIZE_MAX; - maxAllocSize = (cl_ulong)SIZE_MAX; - } - - if (gTestSmallImages) - { - for (imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++) - { - size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - - if (gEnablePitch) - { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - if (gDebugTrace) log_info(" at size %d\n", (int)imageInfo.width); - - image_descriptor dstImageInfo = imageInfo; - dstImageInfo.type = CL_MEM_OBJECT_IMAGE1D; - - int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo, - &dstImageInfo, seed); - if (ret) return -1; - } - } - else if (gTestMaxImages) - { - // Try a specific set of maximum sizes - size_t numbeOfSizes; - size_t sizes[100][3]; - - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1, - maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE1D_BUFFER, - imageInfo.format); - - for (size_t idx = 0; idx < numbeOfSizes; idx++) - { - size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.width = sizes[idx][0]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - - if (gEnablePitch) - { - do - { - rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } - - log_info("Testing %d\n", (int)sizes[idx][0]); - if (gDebugTrace) - log_info(" at max size %d\n", (int)sizes[idx][0]); - - image_descriptor dstImageInfo = imageInfo; - dstImageInfo.type = CL_MEM_OBJECT_IMAGE1D; - - if (test_copy_image_size_1D_buffer(context, queue, &imageInfo, &dstImageInfo, seed)) return -1; } @@ -478,36 +193,194 @@ int test_copy_image_set_1D_buffer_1D(cl_device_id device, cl_context context, // offset arrays, will fit in the global ram space do { - imageInfo.width = + srcImageInfo.width = (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = - imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } - size = (size_t)imageInfo.rowPitch * 4; + size = (size_t)srcImageInfo.rowPitch * 4; } while (size > maxAllocSize || (size * 3) > memSize); if (gDebugTrace) { log_info(" at size %d (row pitch %d) out of %d\n", - (int)imageInfo.width, (int)imageInfo.rowPitch, + (int)srcImageInfo.width, (int)srcImageInfo.rowPitch, (int)maxWidth); } - image_descriptor dstImageInfo = imageInfo; - dstImageInfo.type = CL_MEM_OBJECT_IMAGE1D; - - int ret = test_copy_image_size_1D_buffer(context, queue, &imageInfo, - &dstImageInfo, seed); + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_1D_buffer( + context, queue, &srcImageInfo, &dstImageInfo, seed); + if (ret) return -1; + } + } + + return 0; +} + +int test_copy_image_set_1D_1D_buffer( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) +{ + size_t maxWidth; + cl_ulong maxAllocSize, memSize; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; + RandomSeed seed(gRandomSeed); + size_t pixelSize; + + if (gTestMipmaps) + { + // 1D image buffers don't support mipmaps + // https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#cl_khr_mipmap_image + return 0; + } + + srcImageInfo.format = format; + srcImageInfo.height = srcImageInfo.depth = srcImageInfo.arraySize = + srcImageInfo.slicePitch = 0; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); + + int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH, + sizeof(maxWidth), &maxWidth, NULL); + error |= clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, + sizeof(maxAllocSize), &maxAllocSize, NULL); + error |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize), + &memSize, NULL); + test_error(error, "Unable to get max image 1D buffer size from device"); + + if (memSize > (cl_ulong)SIZE_MAX) + { + memSize = (cl_ulong)SIZE_MAX; + maxAllocSize = (cl_ulong)SIZE_MAX; + } + + if (gTestSmallImages) + { + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) + { + size_t rowPadding = gEnablePitch ? 48 : 0; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; + + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } + + if (gDebugTrace) + log_info(" at size %d\n", (int)srcImageInfo.width); + + dstImageInfo = srcImageInfo; + dstImageInfo.type = dst_type; + dstImageInfo.mem_flags = dst_flags; + + int ret = test_copy_image_size_1D_buffer( + context, queue, &srcImageInfo, &dstImageInfo, seed); + if (ret) return -1; + } + } + else if (gTestMaxImages) + { + // Try a specific set of maximum sizes + size_t numbeOfSizes; + size_t sizes[100][3]; + + get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, 1, 1, 1, + maxAllocSize, memSize, src_type, srcImageInfo.format); + + for (size_t idx = 0; idx < numbeOfSizes; idx++) + { + size_t rowPadding = gEnablePitch ? 48 : 0; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; + + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } + + log_info("Testing %d\n", (int)sizes[idx][0]); + if (gDebugTrace) + log_info(" at max size %d\n", (int)sizes[idx][0]); + + dstImageInfo = srcImageInfo; + dstImageInfo.type = dst_type; + dstImageInfo.mem_flags = dst_flags; + + if (test_copy_image_size_1D_buffer(context, queue, &srcImageInfo, + &dstImageInfo, seed)) + return -1; + } + } + else + { + for (int i = 0; i < NUM_IMAGE_ITERATIONS; i++) + { + cl_ulong size; + size_t rowPadding = gEnablePitch ? 48 : 0; + // Loop until we get a size that a) will fit in the max alloc size + // and b) that an allocation of that image, the result array, plus + // offset arrays, will fit in the global ram space + do + { + srcImageInfo.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } + + size = (size_t)srcImageInfo.rowPitch * 4; + } while (size > maxAllocSize || (size * 3) > memSize); + + if (gDebugTrace) + { + log_info(" at size %d (row pitch %d) out of %d\n", + (int)srcImageInfo.width, (int)srcImageInfo.rowPitch, + (int)maxWidth); + } + + dstImageInfo = srcImageInfo; + dstImageInfo.type = dst_type; + dstImageInfo.mem_flags = dst_flags; + + int ret = test_copy_image_size_1D_buffer( + context, queue, &srcImageInfo, &dstImageInfo, seed); if (ret) return -1; } } diff --git a/test_conformance/images/clCopyImage/test_copy_2D.cpp b/test_conformance/images/clCopyImage/test_copy_2D.cpp index 97cca26c..b7808b80 100644 --- a/test_conformance/images/clCopyImage/test_copy_2D.cpp +++ b/test_conformance/images/clCopyImage/test_copy_2D.cpp @@ -18,38 +18,50 @@ extern int test_copy_image_generic( cl_context context, cl_command_queue queue, image_descriptor *srcImageInfo, image_descriptor *dstImageInfo, const size_t sourcePos[], const size_t destPos[], const size_t regionSize[], MTdata d ); -int test_copy_image_size_2D( cl_context context, cl_command_queue queue, image_descriptor *imageInfo, MTdata d ) +int test_copy_image_size_2D(cl_context context, cl_command_queue queue, + image_descriptor *srcImageInfo, + image_descriptor *dstImageInfo, MTdata d) { size_t sourcePos[ 3 ], destPos[ 3 ], regionSize[ 3 ]; int ret = 0, retCode; - size_t src_lod = 0, src_width_lod = imageInfo->width, src_row_pitch_lod; - size_t src_height_lod = imageInfo->height; - size_t dst_lod = 0, dst_width_lod = imageInfo->width, dst_row_pitch_lod; - size_t dst_height_lod = imageInfo->height; - size_t width_lod = imageInfo->width, height_lod = imageInfo->height; + size_t src_lod = 0, src_width_lod = srcImageInfo->width, src_row_pitch_lod; + size_t src_height_lod = srcImageInfo->height; + size_t dst_lod = 0, dst_width_lod = dstImageInfo->width, dst_row_pitch_lod; + size_t dst_height_lod = dstImageInfo->height; + size_t width_lod = srcImageInfo->width, height_lod = srcImageInfo->height; size_t max_mip_level = 0; if( gTestMipmaps ) { - max_mip_level = imageInfo->num_mip_levels; + max_mip_level = srcImageInfo->num_mip_levels; // Work at a random mip level src_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); dst_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; - src_height_lod = ( imageInfo->height >> src_lod )? ( imageInfo->height >> src_lod ) : 1; - dst_height_lod = ( imageInfo->height >> dst_lod )? ( imageInfo->height >> dst_lod ) : 1; + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; + src_height_lod = (srcImageInfo->height >> src_lod) + ? (srcImageInfo->height >> src_lod) + : 1; + dst_height_lod = (dstImageInfo->height >> dst_lod) + ? (dstImageInfo->height >> dst_lod) + : 1; width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; height_lod = ( src_height_lod > dst_height_lod ) ? dst_height_lod : src_height_lod; - src_row_pitch_lod = src_width_lod * get_pixel_size( imageInfo->format ); - dst_row_pitch_lod = dst_width_lod * get_pixel_size( imageInfo->format ); + src_row_pitch_lod = + src_width_lod * get_pixel_size(srcImageInfo->format); + dst_row_pitch_lod = + dst_width_lod * get_pixel_size(srcImageInfo->format); } // First, try just a full covering region sourcePos[ 0 ] = sourcePos[ 1 ] = sourcePos[ 2 ] = 0; destPos[ 0 ] = destPos[ 1 ] = destPos[ 2 ] = 0; - regionSize[ 0 ] = imageInfo->width; - regionSize[ 1 ] = imageInfo->height; + regionSize[0] = srcImageInfo->width; + regionSize[1] = srcImageInfo->height; regionSize[ 2 ] = 1; if(gTestMipmaps) @@ -60,7 +72,9 @@ int test_copy_image_size_2D( cl_context context, cl_command_queue queue, image_d regionSize[ 1 ] = height_lod; } - retCode = test_copy_image_generic( context, queue, imageInfo, imageInfo, sourcePos, destPos, regionSize, d ); + retCode = + test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + sourcePos, destPos, regionSize, d); if( retCode < 0 ) return retCode; else @@ -74,10 +88,18 @@ int test_copy_image_size_2D( cl_context context, cl_command_queue queue, image_d // Work at a random mip level src_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); dst_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; - src_height_lod = ( imageInfo->height >> src_lod )? ( imageInfo->height >> src_lod ) : 1; - dst_height_lod = ( imageInfo->height >> dst_lod )? ( imageInfo->height >> dst_lod ) : 1; + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; + src_height_lod = (srcImageInfo->height >> src_lod) + ? (srcImageInfo->height >> src_lod) + : 1; + dst_height_lod = (dstImageInfo->height >> dst_lod) + ? (dstImageInfo->height >> dst_lod) + : 1; width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; height_lod = ( src_height_lod > dst_height_lod ) ? dst_height_lod : src_height_lod; sourcePos[ 2 ] = src_lod; @@ -95,7 +117,9 @@ int test_copy_image_size_2D( cl_context context, cl_command_queue queue, image_d destPos[ 1 ] = ( height_lod > regionSize[ 1 ] ) ? (size_t)random_in_range( 0, (int)( height_lod - regionSize[ 1 ] - 1 ), d ) : 0; // Go for it! - retCode = test_copy_image_generic( context, queue, imageInfo, imageInfo, sourcePos, destPos, regionSize, d ); + retCode = + test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + sourcePos, destPos, regionSize, d); if( retCode < 0 ) return retCode; else @@ -105,17 +129,23 @@ int test_copy_image_size_2D( cl_context context, cl_command_queue queue, image_d return ret; } -int test_copy_image_set_2D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ) +int test_copy_image_set_2D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) { + assert(dst_type == src_type); // This test expects to copy 2D -> 2D images size_t maxWidth, maxHeight; cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; RandomSeed seed(gRandomSeed); size_t pixelSize; - imageInfo.format = format; - imageInfo.type = CL_MEM_OBJECT_IMAGE2D; - pixelSize = get_pixel_size( imageInfo.format ); + srcImageInfo.format = format; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL ); @@ -130,32 +160,43 @@ int test_copy_image_set_2D( cl_device_id device, cl_context context, cl_command_ if( gTestSmallImages ) { - for( imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++ ) + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, 0), seed); + if (gTestMipmaps) + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, 0), + seed); - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - for( imageInfo.height = 1; imageInfo.height < 9; imageInfo.height++ ) - { - if( gDebugTrace ) - log_info( " at size %d,%d\n", (int)imageInfo.width, (int)imageInfo.height ); + for (srcImageInfo.height = 1; srcImageInfo.height < 9; + srcImageInfo.height++) + { + if (gDebugTrace) + log_info(" at size %d,%d\n", (int)srcImageInfo.width, + (int)srcImageInfo.height); - int ret = test_copy_image_size_2D( context, queue, &imageInfo, seed ); - if( ret ) - return -1; - } + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_2D(context, queue, &srcImageInfo, + &dstImageInfo, seed); + if (ret) return -1; + } } } else if( gTestMaxImages ) @@ -164,31 +205,42 @@ int test_copy_image_set_2D( cl_device_id device, cl_context context, cl_command_ size_t numbeOfSizes; size_t sizes[100][3]; - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, maxHeight, 1, 1, maxAllocSize, memSize, CL_MEM_OBJECT_IMAGE2D, imageInfo.format); + get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, maxHeight, 1, 1, + maxAllocSize, memSize, src_type, srcImageInfo.format); for( size_t idx = 0; idx < numbeOfSizes; idx++ ) { size_t rowPadding = gEnablePitch ? 48 : 0; - imageInfo.width = sizes[ idx ][ 0 ]; - imageInfo.height = sizes[ idx ][ 1 ]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.height = sizes[idx][1]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; - if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, 0), seed); + if (gTestMipmaps) + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, 0), + seed); - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } log_info( "Testing %d x %d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ] ); if( gDebugTrace ) log_info( " at max size %d,%d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ] ); - if( test_copy_image_size_2D( context, queue, &imageInfo, seed ) ) + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + if (test_copy_image_size_2D(context, queue, &srcImageInfo, + &dstImageInfo, seed)) return -1; } } @@ -202,34 +254,51 @@ int test_copy_image_set_2D( cl_device_id device, cl_context context, cl_command_ // image, the result array, plus offset arrays, will fit in the global ram space do { - imageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - imageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); + srcImageInfo.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + srcImageInfo.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); - if (gTestMipmaps) - { - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, 0), seed); - imageInfo.rowPitch = imageInfo.width * get_pixel_size( imageInfo.format ); - size = compute_mipmapped_image_size( imageInfo ); - size = size*4; - } + if (gTestMipmaps) + { + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, 0), + seed); + srcImageInfo.rowPitch = srcImageInfo.width + * get_pixel_size(srcImageInfo.format); + size = compute_mipmapped_image_size(srcImageInfo); + size = size * 4; + } else { - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - size = (size_t)imageInfo.rowPitch * (size_t)imageInfo.height * 4; + size = + (size_t)srcImageInfo.rowPitch * (size_t)srcImageInfo.height * 4; } } while( size > maxAllocSize || ( size * 3 ) > memSize ); if( gDebugTrace ) - log_info( " at size %d,%d (row pitch %d) out of %d,%d\n", (int)imageInfo.width, (int)imageInfo.height, (int)imageInfo.rowPitch, (int)maxWidth, (int)maxHeight ); - int ret = test_copy_image_size_2D( context, queue, &imageInfo, seed ); + log_info(" at size %d,%d (row pitch %d) out of %d,%d\n", + (int)srcImageInfo.width, (int)srcImageInfo.height, + (int)srcImageInfo.rowPitch, (int)maxWidth, + (int)maxHeight); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_size_2D(context, queue, &srcImageInfo, + &dstImageInfo, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_copy_2D_2D_array.cpp b/test_conformance/images/clCopyImage/test_copy_2D_2D_array.cpp index 9ba8718a..6fc9bc76 100644 --- a/test_conformance/images/clCopyImage/test_copy_2D_2D_array.cpp +++ b/test_conformance/images/clCopyImage/test_copy_2D_2D_array.cpp @@ -36,14 +36,12 @@ static void set_image_dimensions( image_descriptor *imageInfo, size_t width, siz } while ((imageInfo->rowPitch % pixelSize) != 0); } - if (arraySize == 0) + if (imageInfo->type == CL_MEM_OBJECT_IMAGE2D) { - imageInfo->type = CL_MEM_OBJECT_IMAGE2D; imageInfo->slicePitch = 0; } else { - imageInfo->type = CL_MEM_OBJECT_IMAGE2D_ARRAY; imageInfo->slicePitch = imageInfo->rowPitch * (imageInfo->height + slicePadding); } } @@ -205,15 +203,31 @@ int test_copy_image_size_2D_2D_array( cl_context context, cl_command_queue queue } -int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse = false ) +int test_copy_image_set_2D_2D_array( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) { size_t maxWidth, maxHeight, maxArraySize; cl_ulong maxAllocSize, memSize; - image_descriptor srcImageInfo = { 0 }; - image_descriptor dstImageInfo = { 0 }; + const bool reverse = (src_type == CL_MEM_OBJECT_IMAGE2D_ARRAY); + image_descriptor imageInfo2D = { 0 }; + image_descriptor imageInfo2Darray = { 0 }; RandomSeed seed( gRandomSeed ); - srcImageInfo.format = dstImageInfo.format = format; + imageInfo2D.format = imageInfo2Darray.format = format; + imageInfo2D.type = CL_MEM_OBJECT_IMAGE2D; + imageInfo2Darray.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; + if (reverse) + { + imageInfo2Darray.mem_flags = src_flags; + imageInfo2D.mem_flags = dst_flags; + } + else + { + imageInfo2D.mem_flags = src_flags; + imageInfo2Darray.mem_flags = dst_flags; + } int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL ); @@ -229,42 +243,77 @@ int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl if( gTestSmallImages ) { - for( dstImageInfo.width = 4; dstImageInfo.width < 17; dstImageInfo.width++ ) + for (imageInfo2Darray.width = 4; imageInfo2Darray.width < 17; + imageInfo2Darray.width++) { - for( dstImageInfo.height = 4; dstImageInfo.height < 13; dstImageInfo.height++ ) + for (imageInfo2Darray.height = 4; imageInfo2Darray.height < 13; + imageInfo2Darray.height++) { - for( dstImageInfo.arraySize = 4; dstImageInfo.arraySize < 9; dstImageInfo.arraySize++ ) + for (imageInfo2Darray.arraySize = 4; + imageInfo2Darray.arraySize < 9; + imageInfo2Darray.arraySize++) { size_t rowPadding = gEnablePitch ? 256 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - set_image_dimensions( &dstImageInfo, dstImageInfo.width, dstImageInfo.height, dstImageInfo.arraySize, rowPadding, slicePadding ); - set_image_dimensions( &srcImageInfo, dstImageInfo.width, dstImageInfo.height, 0, rowPadding, slicePadding ); + set_image_dimensions( + &imageInfo2Darray, imageInfo2Darray.width, + imageInfo2Darray.height, imageInfo2Darray.arraySize, + rowPadding, slicePadding); + set_image_dimensions(&imageInfo2D, imageInfo2Darray.width, + imageInfo2Darray.height, 0, rowPadding, + slicePadding); if (gTestMipmaps) { - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE2D; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, 0), seed); - dstImageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = 0; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; + imageInfo2D.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels( + imageInfo2D.width, imageInfo2D.height, 0), + seed); + imageInfo2Darray.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels( + imageInfo2Darray.width, + imageInfo2Darray.height, 0), + seed); + imageInfo2D.rowPitch = imageInfo2D.width + * get_pixel_size(imageInfo2D.format); + imageInfo2D.slicePitch = 0; + imageInfo2Darray.rowPitch = imageInfo2Darray.width + * get_pixel_size(imageInfo2Darray.format); + imageInfo2Darray.slicePitch = + imageInfo2Darray.rowPitch * imageInfo2Darray.height; } if( gDebugTrace ) { if (reverse) - log_info( " at size %d,%d,%d to %d,%d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height ); + log_info(" at size %d,%d,%d to %d,%d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo2D.width, + (int)imageInfo2D.height); else - log_info( " at size %d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info(" at size %d,%d to %d,%d,%d\n", + (int)imageInfo2D.width, + (int)imageInfo2D.height, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } int ret; if( reverse ) - ret = test_copy_image_size_2D_2D_array( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_2D_2D_array( + context, queue, &imageInfo2Darray, &imageInfo2D, + seed); else - ret = test_copy_image_size_2D_2D_array( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_2D_2D_array( + context, queue, &imageInfo2D, &imageInfo2Darray, + seed); if( ret ) return -1; } @@ -278,8 +327,12 @@ int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl size_t sizes2DArray[100][3], sizes2D[100][3]; // Try to allocate a bit smaller images because we need the 2D ones as well for the copy. - get_max_sizes(&numberOfSizes2DArray, 100, sizes2DArray, maxWidth, maxHeight, 1, maxArraySize, maxAllocSize/2, memSize/2, CL_MEM_OBJECT_IMAGE2D_ARRAY, dstImageInfo.format); - get_max_sizes(&numberOfSizes2D, 100, sizes2D, maxWidth, maxHeight, 1, 1, maxAllocSize/2, memSize/2, CL_MEM_OBJECT_IMAGE2D, dstImageInfo.format); + get_max_sizes(&numberOfSizes2DArray, 100, sizes2DArray, maxWidth, + maxHeight, 1, maxArraySize, maxAllocSize / 2, memSize / 2, + CL_MEM_OBJECT_IMAGE2D_ARRAY, imageInfo2Darray.format); + get_max_sizes(&numberOfSizes2D, 100, sizes2D, maxWidth, maxHeight, 1, 1, + maxAllocSize / 2, memSize / 2, CL_MEM_OBJECT_IMAGE2D, + imageInfo2Darray.format); for( size_t i = 0; i < numberOfSizes2D; i++ ) { @@ -288,56 +341,94 @@ int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl size_t rowPadding = gEnablePitch ? 256 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - set_image_dimensions( &dstImageInfo, sizes2DArray[ j ][ 0 ], sizes2DArray[ j ][ 1 ], sizes2DArray[ j ][ 2 ], rowPadding, slicePadding ); - set_image_dimensions( &srcImageInfo, sizes2D[ i ][ 0 ], sizes2D[ i ][ 1 ], 0, rowPadding, slicePadding ); + set_image_dimensions(&imageInfo2Darray, sizes2DArray[j][0], + sizes2DArray[j][1], sizes2DArray[j][2], + rowPadding, slicePadding); + set_image_dimensions(&imageInfo2D, sizes2D[i][0], sizes2D[i][1], 0, + rowPadding, slicePadding); - cl_ulong dstSize = get_image_size(&dstImageInfo); - cl_ulong srcSize = get_image_size(&srcImageInfo); + cl_ulong dstSize = get_image_size(&imageInfo2Darray); + cl_ulong srcSize = get_image_size(&imageInfo2D); if (gTestMipmaps) { - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE2D; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, 0), seed); - dstImageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = 0; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; - dstSize = 4 * compute_mipmapped_image_size( dstImageInfo ); - srcSize = 4 * compute_mipmapped_image_size( srcImageInfo ); + imageInfo2D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2D.width, + imageInfo2D.height, 0), + seed); + imageInfo2Darray.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2Darray.width, + imageInfo2Darray.height, 0), + seed); + imageInfo2D.rowPitch = + imageInfo2D.width * get_pixel_size(imageInfo2D.format); + imageInfo2D.slicePitch = 0; + imageInfo2Darray.rowPitch = imageInfo2Darray.width + * get_pixel_size(imageInfo2Darray.format); + imageInfo2Darray.slicePitch = + imageInfo2Darray.rowPitch * imageInfo2Darray.height; + dstSize = 4 * compute_mipmapped_image_size(imageInfo2Darray); + srcSize = 4 * compute_mipmapped_image_size(imageInfo2D); } if( dstSize < maxAllocSize && dstSize < ( memSize / 3 ) && srcSize < maxAllocSize && srcSize < ( memSize / 3 ) ) { if (reverse) - log_info( "Testing %d x %d x %d to %d x %d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height ); + log_info("Testing %d x %d x %d to %d x %d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo2D.width, (int)imageInfo2D.height); else - log_info( "Testing %d x %d to %d x %d x %d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info("Testing %d x %d to %d x %d x %d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); if( gDebugTrace ) { if (reverse) - log_info( " at max size %d,%d,%d to %d,%d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height ); + log_info(" at max size %d,%d,%d to %d,%d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo2D.width, (int)imageInfo2D.height); else - log_info( " at max size %d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info(" at max size %d,%d to %d,%d,%d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } int ret; if( reverse ) - ret = test_copy_image_size_2D_2D_array( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_2D_2D_array( + context, queue, &imageInfo2Darray, &imageInfo2D, seed); else - ret = test_copy_image_size_2D_2D_array( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_2D_2D_array( + context, queue, &imageInfo2D, &imageInfo2Darray, seed); if( ret ) return -1; } else { if (reverse) - log_info("Not testing max size %d x %d x %d to %d x %d due to memory constraints.\n", - (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height); + log_info("Not testing max size %d x %d x %d to %d x %d due " + "to memory constraints.\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo2D.width, (int)imageInfo2D.height); else - log_info("Not testing max size %d x %d to %d x %d x %d due to memory constraints.\n", - (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize); + log_info("Not testing max size %d x %d to %d x %d x %d due " + "to memory constraints.\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } } @@ -354,47 +445,81 @@ int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl // image, the result array, plus offset arrays, will fit in the global ram space do { - dstImageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - dstImageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); - dstImageInfo.arraySize = (size_t)random_log_in_range( 16, (int)maxArraySize / 32, seed ); - srcImageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - srcImageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); + imageInfo2Darray.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + imageInfo2Darray.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); + imageInfo2Darray.arraySize = (size_t)random_log_in_range( + 16, (int)maxArraySize / 32, seed); + imageInfo2D.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + imageInfo2D.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); if (gTestMipmaps) { - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE2D; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, 0), seed); - dstImageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = 0; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; - srcSize = 4 * compute_mipmapped_image_size( srcImageInfo ); - dstSize = 4 * compute_mipmapped_image_size( dstImageInfo ); + imageInfo2D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2D.width, + imageInfo2D.height, 0), + seed); + imageInfo2Darray.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2Darray.width, + imageInfo2Darray.height, + 0), + seed); + imageInfo2D.rowPitch = + imageInfo2D.width * get_pixel_size(imageInfo2D.format); + imageInfo2D.slicePitch = 0; + imageInfo2Darray.rowPitch = imageInfo2Darray.width + * get_pixel_size(imageInfo2Darray.format); + imageInfo2Darray.slicePitch = + imageInfo2Darray.rowPitch * imageInfo2Darray.height; + srcSize = 4 * compute_mipmapped_image_size(imageInfo2D); + dstSize = + 4 * compute_mipmapped_image_size(imageInfo2Darray); } else { - set_image_dimensions( &srcImageInfo, srcImageInfo.width, srcImageInfo.height, 0, rowPadding, slicePadding ); - set_image_dimensions( &dstImageInfo, dstImageInfo.width, dstImageInfo.height, dstImageInfo.arraySize, rowPadding, slicePadding ); + set_image_dimensions(&imageInfo2D, imageInfo2D.width, + imageInfo2D.height, 0, rowPadding, + slicePadding); + set_image_dimensions( + &imageInfo2Darray, imageInfo2Darray.width, + imageInfo2Darray.height, imageInfo2Darray.arraySize, + rowPadding, slicePadding); - srcSize = (cl_ulong)srcImageInfo.rowPitch * (cl_ulong)srcImageInfo.height * 4; - dstSize = (cl_ulong)dstImageInfo.slicePitch * (cl_ulong)dstImageInfo.arraySize * 4; + srcSize = (cl_ulong)imageInfo2D.rowPitch + * (cl_ulong)imageInfo2D.height * 4; + dstSize = (cl_ulong)imageInfo2Darray.slicePitch + * (cl_ulong)imageInfo2Darray.arraySize * 4; } } while( srcSize > maxAllocSize || ( srcSize * 3 ) > memSize || dstSize > maxAllocSize || ( dstSize * 3 ) > memSize); if( gDebugTrace ) { if (reverse) - log_info( " at size %d,%d,%d to %d,%d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height ); + log_info(" at size %d,%d,%d to %d,%d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo2D.width, (int)imageInfo2D.height); else - log_info( " at size %d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info(" at size %d,%d to %d,%d,%d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } int ret; if( reverse ) - ret = test_copy_image_size_2D_2D_array( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_2D_2D_array( + context, queue, &imageInfo2Darray, &imageInfo2D, seed); else - ret = test_copy_image_size_2D_2D_array( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_2D_2D_array( + context, queue, &imageInfo2D, &imageInfo2Darray, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_copy_2D_3D.cpp b/test_conformance/images/clCopyImage/test_copy_2D_3D.cpp index 5f522e3e..d04356c5 100644 --- a/test_conformance/images/clCopyImage/test_copy_2D_3D.cpp +++ b/test_conformance/images/clCopyImage/test_copy_2D_3D.cpp @@ -36,12 +36,8 @@ static void set_image_dimensions( image_descriptor *imageInfo, size_t width, siz } while ((imageInfo->rowPitch % pixelSize) != 0); } - imageInfo->slicePitch = imageInfo->rowPitch * (imageInfo->height + slicePadding); - - if (depth == 0) - imageInfo->type = CL_MEM_OBJECT_IMAGE2D; - else - imageInfo->type = CL_MEM_OBJECT_IMAGE3D; + imageInfo->slicePitch = + imageInfo->rowPitch * (imageInfo->height + slicePadding); } @@ -209,15 +205,33 @@ int test_copy_image_size_2D_3D( cl_context context, cl_command_queue queue, imag } -int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse = false ) +int test_copy_image_set_2D_3D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, + cl_mem_flags dst_flags, + cl_mem_object_type dst_type, + cl_image_format *format) { size_t maxWidth, maxHeight, max3DWidth, max3DHeight, max3DDepth; cl_ulong maxAllocSize, memSize; - image_descriptor srcImageInfo = { 0 }; - image_descriptor dstImageInfo = { 0 }; + const bool reverse = (dst_type == CL_MEM_OBJECT_IMAGE2D); + image_descriptor imageInfo2D = { 0 }; + image_descriptor imageInfo3D = { 0 }; RandomSeed seed( gRandomSeed ); - srcImageInfo.format = dstImageInfo.format = format; + imageInfo2D.format = imageInfo3D.format = format; + imageInfo2D.type = CL_MEM_OBJECT_IMAGE2D; + imageInfo3D.type = CL_MEM_OBJECT_IMAGE3D; + if (reverse) + { + imageInfo3D.mem_flags = src_flags; + imageInfo2D.mem_flags = dst_flags; + } + else + { + imageInfo2D.mem_flags = src_flags; + imageInfo3D.mem_flags = dst_flags; + } int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL ); @@ -235,38 +249,62 @@ int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_comma if( gTestSmallImages ) { - for( dstImageInfo.width = 4; dstImageInfo.width < 17; dstImageInfo.width++ ) + for (imageInfo3D.width = 4; imageInfo3D.width < 17; imageInfo3D.width++) { - for( dstImageInfo.height = 4; dstImageInfo.height < 13; dstImageInfo.height++ ) + for (imageInfo3D.height = 4; imageInfo3D.height < 13; + imageInfo3D.height++) { - for( dstImageInfo.depth = 4; dstImageInfo.depth < 9; dstImageInfo.depth++ ) + for (imageInfo3D.depth = 4; imageInfo3D.depth < 9; + imageInfo3D.depth++) { size_t rowPadding = gEnablePitch ? 256 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - set_image_dimensions( &dstImageInfo, dstImageInfo.width, dstImageInfo.height, dstImageInfo.depth, rowPadding, slicePadding ); - set_image_dimensions( &srcImageInfo, dstImageInfo.width, dstImageInfo.height, 0, rowPadding, slicePadding ); + set_image_dimensions(&imageInfo3D, imageInfo3D.width, + imageInfo3D.height, imageInfo3D.depth, + rowPadding, slicePadding); + set_image_dimensions(&imageInfo2D, imageInfo3D.width, + imageInfo3D.height, 0, rowPadding, + slicePadding); if (gTestMipmaps) { - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE2D; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, dstImageInfo.depth), seed); - dstImageInfo.type = CL_MEM_OBJECT_IMAGE3D; - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = 0; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; + imageInfo2D.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels( + imageInfo2D.width, imageInfo2D.height, 0), + seed); + imageInfo3D.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo3D.width, + imageInfo3D.height, + imageInfo3D.depth), + seed); + imageInfo2D.rowPitch = imageInfo2D.width + * get_pixel_size(imageInfo2D.format); + imageInfo2D.slicePitch = 0; + imageInfo3D.rowPitch = imageInfo3D.width + * get_pixel_size(imageInfo3D.format); + imageInfo3D.slicePitch = + imageInfo3D.rowPitch * imageInfo3D.height; } if( gDebugTrace ) - log_info( " at size %d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.depth ); + log_info( + " at size %d,%d to %d,%d,%d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); int ret; if( reverse ) - ret = test_copy_image_size_2D_3D( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_2D_3D( + context, queue, &imageInfo3D, &imageInfo2D, seed); else - ret = test_copy_image_size_2D_3D( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_2D_3D( + context, queue, &imageInfo2D, &imageInfo3D, seed); if( ret ) return -1; } @@ -280,8 +318,12 @@ int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_comma size_t sizes3D[100][3], sizes2D[100][3]; // Try to allocate a bit smaller images because we need the 2D ones as well for the copy. - get_max_sizes(&numberOfSizes3D, 100, sizes3D, max3DWidth, max3DHeight, max3DDepth, 1, maxAllocSize/2, memSize/2, CL_MEM_OBJECT_IMAGE3D, dstImageInfo.format); - get_max_sizes(&numberOfSizes2D, 100, sizes2D, maxWidth, maxHeight, 1, 1, maxAllocSize/2, memSize/2, CL_MEM_OBJECT_IMAGE2D, srcImageInfo.format); + get_max_sizes(&numberOfSizes3D, 100, sizes3D, max3DWidth, max3DHeight, + max3DDepth, 1, maxAllocSize / 2, memSize / 2, + CL_MEM_OBJECT_IMAGE3D, imageInfo3D.format); + get_max_sizes(&numberOfSizes2D, 100, sizes2D, maxWidth, maxHeight, 1, 1, + maxAllocSize / 2, memSize / 2, CL_MEM_OBJECT_IMAGE2D, + imageInfo2D.format); for( size_t i = 0; i < numberOfSizes2D; i++ ) for( size_t j = 0; j < numberOfSizes3D; j++ ) @@ -289,42 +331,65 @@ int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_comma size_t rowPadding = gEnablePitch ? 256 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - set_image_dimensions( &dstImageInfo, sizes3D[ j ][ 0 ], sizes3D[ j ][ 1 ], sizes3D[ j ][ 2 ], rowPadding, slicePadding ); - set_image_dimensions( &srcImageInfo, sizes2D[ i ][ 0 ], sizes2D[ i ][ 1 ], 0, rowPadding, slicePadding ); - cl_ulong dstSize = get_image_size(&dstImageInfo); - cl_ulong srcSize = get_image_size(&srcImageInfo); + set_image_dimensions(&imageInfo3D, sizes3D[j][0], sizes3D[j][1], + sizes3D[j][2], rowPadding, slicePadding); + set_image_dimensions(&imageInfo2D, sizes2D[i][0], sizes2D[i][1], 0, + rowPadding, slicePadding); + cl_ulong dstSize = get_image_size(&imageInfo3D); + cl_ulong srcSize = get_image_size(&imageInfo2D); if (gTestMipmaps) { - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE2D; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, dstImageInfo.depth), seed); - dstImageInfo.type = CL_MEM_OBJECT_IMAGE3D; - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = 0; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; - dstSize = 4 * compute_mipmapped_image_size( dstImageInfo ); - srcSize = 4 * compute_mipmapped_image_size( srcImageInfo ); + imageInfo2D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2D.width, + imageInfo2D.height, 0), + seed); + imageInfo3D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo3D.width, + imageInfo3D.height, + imageInfo3D.depth), + seed); + imageInfo2D.rowPitch = + imageInfo2D.width * get_pixel_size(imageInfo2D.format); + imageInfo2D.slicePitch = 0; + imageInfo3D.rowPitch = + imageInfo3D.width * get_pixel_size(imageInfo3D.format); + imageInfo3D.slicePitch = + imageInfo3D.rowPitch * imageInfo3D.height; + dstSize = 4 * compute_mipmapped_image_size(imageInfo3D); + srcSize = 4 * compute_mipmapped_image_size(imageInfo2D); } if( dstSize < maxAllocSize && dstSize < ( memSize / 3 ) && srcSize < maxAllocSize && srcSize < ( memSize / 3 ) ) { - log_info( "Testing %d x %d to %d x %d x %d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.depth ); + log_info("Testing %d x %d to %d x %d x %d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); if( gDebugTrace ) - log_info( " at max size %d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.depth ); + log_info(" at max size %d,%d to %d,%d,%d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); int ret; if( reverse ) - ret = test_copy_image_size_2D_3D( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_2D_3D( + context, queue, &imageInfo3D, &imageInfo2D, seed); else - ret = test_copy_image_size_2D_3D( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_2D_3D( + context, queue, &imageInfo2D, &imageInfo3D, seed); if( ret ) return -1; } else { - log_info("Not testing max size %d x %d to %d x %d x %d due to memory constraints.\n", - (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.depth); + log_info("Not testing max size %d x %d to %d x %d x %d due to " + "memory constraints.\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); } } @@ -341,42 +406,68 @@ int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_comma // image, the result array, plus offset arrays, will fit in the global ram space do { - dstImageInfo.width = (size_t)random_log_in_range( 16, (int)max3DWidth / 32, seed ); - dstImageInfo.height = (size_t)random_log_in_range( 16, (int)max3DHeight / 32, seed ); - dstImageInfo.depth = (size_t)random_log_in_range( 16, (int)max3DDepth / 32, seed ); - srcImageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - srcImageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); + imageInfo3D.width = + (size_t)random_log_in_range(16, (int)max3DWidth / 32, seed); + imageInfo3D.height = (size_t)random_log_in_range( + 16, (int)max3DHeight / 32, seed); + imageInfo3D.depth = + (size_t)random_log_in_range(16, (int)max3DDepth / 32, seed); + imageInfo2D.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + imageInfo2D.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); if (gTestMipmaps) { - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE2D; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, dstImageInfo.depth), seed); - dstImageInfo.type = CL_MEM_OBJECT_IMAGE3D; - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = 0; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; - srcSize = 4 * compute_mipmapped_image_size( srcImageInfo ); - dstSize = 4 * compute_mipmapped_image_size( dstImageInfo ); + imageInfo2D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2D.width, + imageInfo2D.height, 0), + seed); + imageInfo3D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo3D.width, + imageInfo3D.height, + imageInfo3D.depth), + seed); + imageInfo2D.rowPitch = + imageInfo2D.width * get_pixel_size(imageInfo2D.format); + imageInfo2D.slicePitch = 0; + imageInfo3D.rowPitch = + imageInfo3D.width * get_pixel_size(imageInfo3D.format); + imageInfo3D.slicePitch = + imageInfo3D.rowPitch * imageInfo3D.height; + srcSize = 4 * compute_mipmapped_image_size(imageInfo2D); + dstSize = 4 * compute_mipmapped_image_size(imageInfo3D); } else { - set_image_dimensions( &srcImageInfo, srcImageInfo.width, srcImageInfo.height, 0, rowPadding, slicePadding ); - set_image_dimensions( &dstImageInfo, dstImageInfo.width, dstImageInfo.height, dstImageInfo.depth, rowPadding, slicePadding ); + set_image_dimensions(&imageInfo2D, imageInfo2D.width, + imageInfo2D.height, 0, rowPadding, + slicePadding); + set_image_dimensions(&imageInfo3D, imageInfo3D.width, + imageInfo3D.height, imageInfo3D.depth, + rowPadding, slicePadding); - srcSize = (cl_ulong)srcImageInfo.rowPitch * (cl_ulong)srcImageInfo.height * 4; - dstSize = (cl_ulong)dstImageInfo.slicePitch * (cl_ulong)dstImageInfo.depth * 4; + srcSize = (cl_ulong)imageInfo2D.rowPitch + * (cl_ulong)imageInfo2D.height * 4; + dstSize = (cl_ulong)imageInfo3D.slicePitch + * (cl_ulong)imageInfo3D.depth * 4; } } while( srcSize > maxAllocSize || ( srcSize * 3 ) > memSize || dstSize > maxAllocSize || ( dstSize * 3 ) > memSize); if( gDebugTrace ) - log_info( " at size %d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.depth ); + log_info(" at size %d,%d to %d,%d,%d\n", + (int)imageInfo2D.width, (int)imageInfo2D.height, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); int ret; if( reverse ) - ret = test_copy_image_size_2D_3D( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_2D_3D(context, queue, &imageInfo3D, + &imageInfo2D, seed); else - ret = test_copy_image_size_2D_3D( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_2D_3D(context, queue, &imageInfo2D, + &imageInfo3D, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_copy_2D_array.cpp b/test_conformance/images/clCopyImage/test_copy_2D_array.cpp index 3376bf9a..72fc19ba 100644 --- a/test_conformance/images/clCopyImage/test_copy_2D_array.cpp +++ b/test_conformance/images/clCopyImage/test_copy_2D_array.cpp @@ -19,26 +19,39 @@ extern int test_copy_image_generic( cl_context context, cl_command_queue queue, image_descriptor *srcImageInfo, image_descriptor *dstImageInfo, const size_t sourcePos[], const size_t destPos[], const size_t regionSize[], MTdata d ); -int test_copy_image_2D_array( cl_context context, cl_command_queue queue, image_descriptor *imageInfo, MTdata d ) +int test_copy_image_2D_array(cl_context context, cl_command_queue queue, + image_descriptor *srcImageInfo, + image_descriptor *dstImageInfo, MTdata d) { size_t srcPos[] = { 0, 0, 0, 0}, dstPos[] = {0, 0, 0, 0}; - size_t region[] = { imageInfo->width, imageInfo->height, imageInfo->arraySize }; + size_t region[] = { srcImageInfo->width, srcImageInfo->height, + srcImageInfo->arraySize }; - size_t src_lod = 0, src_width_lod = imageInfo->width, src_height_lod = imageInfo->height; - size_t dst_lod = 0, dst_width_lod = imageInfo->width, dst_height_lod = imageInfo->height; - size_t width_lod = imageInfo->width, height_lod = imageInfo->height; + size_t src_lod = 0, src_width_lod = srcImageInfo->width, + src_height_lod = srcImageInfo->height; + size_t dst_lod = 0, dst_width_lod = dstImageInfo->width, + dst_height_lod = dstImageInfo->height; + size_t width_lod = srcImageInfo->width, height_lod = srcImageInfo->height; size_t max_mip_level; if( gTestMipmaps ) { - max_mip_level = imageInfo->num_mip_levels; + max_mip_level = srcImageInfo->num_mip_levels; // Work at a random mip level src_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); dst_lod = (size_t)random_in_range( 0, max_mip_level ? max_mip_level - 1 : 0, d ); - src_width_lod = ( imageInfo->width >> src_lod )? ( imageInfo->width >> src_lod ) : 1; - dst_width_lod = ( imageInfo->width >> dst_lod )? ( imageInfo->width >> dst_lod ) : 1; - src_height_lod = ( imageInfo->height >> src_lod )? ( imageInfo->height >> src_lod ) : 1; - dst_height_lod = ( imageInfo->height >> dst_lod )? ( imageInfo->height >> dst_lod ) : 1; + src_width_lod = (srcImageInfo->width >> src_lod) + ? (srcImageInfo->width >> src_lod) + : 1; + dst_width_lod = (dstImageInfo->width >> dst_lod) + ? (dstImageInfo->width >> dst_lod) + : 1; + src_height_lod = (srcImageInfo->height >> src_lod) + ? (srcImageInfo->height >> src_lod) + : 1; + dst_height_lod = (dstImageInfo->height >> dst_lod) + ? (dstImageInfo->height >> dst_lod) + : 1; width_lod = ( src_width_lod > dst_width_lod ) ? dst_width_lod : src_width_lod; height_lod = ( src_height_lod > dst_height_lod ) ? dst_height_lod : src_height_lod; @@ -47,20 +60,31 @@ int test_copy_image_2D_array( cl_context context, cl_command_queue queue, image_ srcPos[ 3 ] = src_lod; dstPos[ 3 ] = dst_lod; } - return test_copy_image_generic( context, queue, imageInfo, imageInfo, srcPos, dstPos, region, d ); +return test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + srcPos, dstPos, region, d); } -int test_copy_image_set_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ) +int test_copy_image_set_2D_array(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, + cl_mem_flags dst_flags, + cl_mem_object_type dst_type, + cl_image_format *format) { + assert( + dst_type + == src_type); // This test expects to copy 2D array -> 2D array images size_t maxWidth, maxHeight, maxArraySize; cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; RandomSeed seed( gRandomSeed ); size_t pixelSize; - imageInfo.format = format; - imageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - pixelSize = get_pixel_size( imageInfo.format ); + srcImageInfo.format = format; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL ); @@ -76,33 +100,49 @@ int test_copy_image_set_2D_array( cl_device_id device, cl_context context, cl_co if( gTestSmallImages ) { - for( imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++ ) + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) { size_t rowPadding = gEnablePitch ? 80 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, 0), seed); + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, 0), + seed); if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } - for( imageInfo.height = 1; imageInfo.height < 9; imageInfo.height++ ) + for (srcImageInfo.height = 1; srcImageInfo.height < 9; + srcImageInfo.height++) { - imageInfo.slicePitch = imageInfo.rowPitch * (imageInfo.height + slicePadding); + srcImageInfo.slicePitch = srcImageInfo.rowPitch + * (srcImageInfo.height + slicePadding); - for( imageInfo.arraySize = 2; imageInfo.arraySize < 9; imageInfo.arraySize++ ) + for (srcImageInfo.arraySize = 2; srcImageInfo.arraySize < 9; + srcImageInfo.arraySize++) { if( gDebugTrace ) - log_info( " at size %d,%d,%d\n", (int)imageInfo.width, (int)imageInfo.height, (int)imageInfo.arraySize ); - int ret = test_copy_image_2D_array( context, queue, &imageInfo, seed ); + log_info(" at size %d,%d,%d\n", + (int)srcImageInfo.width, + (int)srcImageInfo.height, + (int)srcImageInfo.arraySize); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_2D_array( + context, queue, &srcImageInfo, &dstImageInfo, seed); if( ret ) return -1; } @@ -114,34 +154,46 @@ int test_copy_image_set_2D_array( cl_device_id device, cl_context context, cl_co // Try a specific set of maximum sizes size_t numbeOfSizes; size_t sizes[100][3]; - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, maxHeight, 1, maxArraySize, maxAllocSize, memSize, imageInfo.type, imageInfo.format); + get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, maxHeight, 1, + maxArraySize, maxAllocSize, memSize, srcImageInfo.type, + srcImageInfo.format); for( size_t idx = 0; idx < numbeOfSizes; idx++ ) { size_t rowPadding = gEnablePitch ? 80 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - imageInfo.width = sizes[ idx ][ 0 ]; - imageInfo.height = sizes[ idx ][ 1 ]; - imageInfo.arraySize = sizes[ idx ][ 2 ]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.height = sizes[idx][1]; + srcImageInfo.arraySize = sizes[idx][2]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, 0), seed); + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, 0), + seed); if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } - imageInfo.slicePitch = imageInfo.rowPitch * (imageInfo.height + slicePadding); + srcImageInfo.slicePitch = + srcImageInfo.rowPitch * (srcImageInfo.height + slicePadding); log_info( "Testing %d x %d x %d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ], (int)sizes[ idx ][ 2 ] ); if( gDebugTrace ) log_info( " at max size %d,%d,%d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ], (int)sizes[ idx ][ 2 ] ); - if( test_copy_image_2D_array( context, queue, &imageInfo, seed ) ) + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + if (test_copy_image_2D_array(context, queue, &srcImageInfo, + &dstImageInfo, seed)) return -1; } } @@ -156,38 +208,61 @@ int test_copy_image_set_2D_array( cl_device_id device, cl_context context, cl_co // image, the result array, plus offset arrays, will fit in the global ram space do { - imageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - imageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); - imageInfo.arraySize = (size_t)random_log_in_range( 16, (int)maxArraySize / 32, seed ); + srcImageInfo.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + srcImageInfo.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); + srcImageInfo.arraySize = (size_t)random_log_in_range( + 16, (int)maxArraySize / 32, seed); if (gTestMipmaps) { - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, 0), seed); - imageInfo.rowPitch = imageInfo.width * get_pixel_size( imageInfo.format ); - imageInfo.slicePitch = imageInfo.rowPitch * imageInfo.height; - size = compute_mipmapped_image_size( imageInfo ); + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, 0), + seed); + srcImageInfo.rowPitch = srcImageInfo.width + * get_pixel_size(srcImageInfo.format); + srcImageInfo.slicePitch = + srcImageInfo.rowPitch * srcImageInfo.height; + size = compute_mipmapped_image_size(srcImageInfo); size = size*4; } else { - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - imageInfo.slicePitch = imageInfo.rowPitch * (imageInfo.height + slicePadding); + srcImageInfo.slicePitch = srcImageInfo.rowPitch + * (srcImageInfo.height + slicePadding); - size = (cl_ulong)imageInfo.slicePitch * (cl_ulong)imageInfo.arraySize * 4 * 4; + size = (cl_ulong)srcImageInfo.slicePitch + * (cl_ulong)srcImageInfo.arraySize * 4 * 4; } } while( size > maxAllocSize || ( size * 3 ) > memSize ); if( gDebugTrace ) - log_info( " at size %d,%d,%d (pitch %d,%d) out of %d,%d,%d\n", (int)imageInfo.width, (int)imageInfo.height, (int)imageInfo.arraySize, (int)imageInfo.rowPitch, (int)imageInfo.slicePitch, (int)maxWidth, (int)maxHeight, (int)maxArraySize ); - int ret = test_copy_image_2D_array( context, queue, &imageInfo,seed ); + log_info(" at size %d,%d,%d (pitch %d,%d) out of %d,%d,%d\n", + (int)srcImageInfo.width, (int)srcImageInfo.height, + (int)srcImageInfo.arraySize, + (int)srcImageInfo.rowPitch, + (int)srcImageInfo.slicePitch, (int)maxWidth, + (int)maxHeight, (int)maxArraySize); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_2D_array(context, queue, &srcImageInfo, + &dstImageInfo, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_copy_3D.cpp b/test_conformance/images/clCopyImage/test_copy_3D.cpp index cdfdccec..f7e7706e 100644 --- a/test_conformance/images/clCopyImage/test_copy_3D.cpp +++ b/test_conformance/images/clCopyImage/test_copy_3D.cpp @@ -19,34 +19,49 @@ extern int test_copy_image_generic( cl_context context, cl_command_queue queue, image_descriptor *srcImageInfo, image_descriptor *dstImageInfo, const size_t sourcePos[], const size_t destPos[], const size_t regionSize[], MTdata d ); -int test_copy_image_3D( cl_context context, cl_command_queue queue, image_descriptor *imageInfo, MTdata d ) +int test_copy_image_3D(cl_context context, cl_command_queue queue, + image_descriptor *srcImageInfo, + image_descriptor *dstImageInfo, MTdata d) { size_t origin[] = { 0, 0, 0, 0}; - size_t region[] = { imageInfo->width, imageInfo->height, imageInfo->depth }; + size_t region[] = { srcImageInfo->width, srcImageInfo->height, + srcImageInfo->depth }; if( gTestMipmaps ) { - size_t lod = (imageInfo->num_mip_levels > 1 )? (size_t)random_in_range( 0, imageInfo->num_mip_levels - 1, d ) : 0 ; + size_t lod = (srcImageInfo->num_mip_levels > 1) + ? (size_t)random_in_range(0, srcImageInfo->num_mip_levels - 1, d) + : 0; origin[ 3 ] = lod; - region[ 0 ] = ( imageInfo->width >> lod ) ? ( imageInfo->width >> lod ) : 1; - region[ 1 ] = ( imageInfo->height >> lod ) ? ( imageInfo->height >> lod ) : 1; - region[ 2 ] = ( imageInfo->depth >> lod ) ? ( imageInfo->depth >> lod ) : 1; + region[0] = + (srcImageInfo->width >> lod) ? (srcImageInfo->width >> lod) : 1; + region[1] = + (srcImageInfo->height >> lod) ? (srcImageInfo->height >> lod) : 1; + region[2] = + (srcImageInfo->depth >> lod) ? (srcImageInfo->depth >> lod) : 1; } - return test_copy_image_generic( context, queue, imageInfo, imageInfo, origin, origin, region, d ); + return test_copy_image_generic(context, queue, srcImageInfo, dstImageInfo, + origin, origin, region, d); } -int test_copy_image_set_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ) +int test_copy_image_set_3D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) { + assert(dst_type == src_type); // This test expects to copy 3D -> 3D images size_t maxWidth, maxHeight, maxDepth; cl_ulong maxAllocSize, memSize; - image_descriptor imageInfo = { 0 }; + image_descriptor srcImageInfo = { 0 }; + image_descriptor dstImageInfo = { 0 }; RandomSeed seed( gRandomSeed ); size_t pixelSize; - imageInfo.format = format; - imageInfo.type = CL_MEM_OBJECT_IMAGE3D; - pixelSize = get_pixel_size( imageInfo.format ); + srcImageInfo.format = format; + srcImageInfo.type = src_type; + srcImageInfo.mem_flags = src_flags; + pixelSize = get_pixel_size(srcImageInfo.format); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL ); @@ -62,32 +77,48 @@ int test_copy_image_set_3D( cl_device_id device, cl_context context, cl_command_ if( gTestSmallImages ) { - for( imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++ ) + for (srcImageInfo.width = 1; srcImageInfo.width < 13; + srcImageInfo.width++) { size_t rowPadding = gEnablePitch ? 80 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, imageInfo.depth), seed); + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, + srcImageInfo.depth), + seed); if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } - for( imageInfo.height = 1; imageInfo.height < 9; imageInfo.height++ ) + for (srcImageInfo.height = 1; srcImageInfo.height < 9; + srcImageInfo.height++) { - imageInfo.slicePitch = imageInfo.rowPitch * (imageInfo.height + slicePadding); - for( imageInfo.depth = 2; imageInfo.depth < 9; imageInfo.depth++ ) + srcImageInfo.slicePitch = srcImageInfo.rowPitch + * (srcImageInfo.height + slicePadding); + for (srcImageInfo.depth = 2; srcImageInfo.depth < 9; + srcImageInfo.depth++) { if( gDebugTrace ) - log_info( " at size %d,%d,%d\n", (int)imageInfo.width, (int)imageInfo.height, (int)imageInfo.depth ); - int ret = test_copy_image_3D( context, queue, &imageInfo, seed ); + log_info( + " at size %d,%d,%d\n", (int)srcImageInfo.width, + (int)srcImageInfo.height, (int)srcImageInfo.depth); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_3D(context, queue, &srcImageInfo, + &dstImageInfo, seed); if( ret ) return -1; } @@ -99,34 +130,47 @@ int test_copy_image_set_3D( cl_device_id device, cl_context context, cl_command_ // Try a specific set of maximum sizes size_t numbeOfSizes; size_t sizes[100][3]; - get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, maxHeight, maxDepth, 1, maxAllocSize, memSize, imageInfo.type, imageInfo.format); + get_max_sizes(&numbeOfSizes, 100, sizes, maxWidth, maxHeight, maxDepth, + 1, maxAllocSize, memSize, srcImageInfo.type, + srcImageInfo.format); for( size_t idx = 0; idx < numbeOfSizes; idx++ ) { size_t rowPadding = gEnablePitch ? 80 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - imageInfo.width = sizes[ idx ][ 0 ]; - imageInfo.height = sizes[ idx ][ 1 ]; - imageInfo.depth = sizes[ idx ][ 2 ]; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.width = sizes[idx][0]; + srcImageInfo.height = sizes[idx][1]; + srcImageInfo.depth = sizes[idx][2]; + srcImageInfo.rowPitch = srcImageInfo.width * pixelSize + rowPadding; if (gTestMipmaps) - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, imageInfo.depth), seed); + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, + srcImageInfo.depth), + seed); if (gEnablePitch) { do { rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); } - imageInfo.slicePitch = imageInfo.rowPitch * (imageInfo.height + slicePadding); + srcImageInfo.slicePitch = + srcImageInfo.rowPitch * (srcImageInfo.height + slicePadding); log_info( "Testing %d x %d x %d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ], (int)sizes[ idx ][ 2 ] ); if( gDebugTrace ) log_info( " at max size %d,%d,%d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ], (int)sizes[ idx ][ 2 ] ); - if( test_copy_image_3D( context, queue, &imageInfo, seed ) ) + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + if (test_copy_image_3D(context, queue, &srcImageInfo, &dstImageInfo, + seed)) return -1; } } @@ -142,39 +186,62 @@ int test_copy_image_set_3D( cl_device_id device, cl_context context, cl_command_ // image, the result array, plus offset arrays, will fit in the global ram space do { - imageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - imageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); - imageInfo.depth = (size_t)random_log_in_range( 16, (int)maxDepth / 32,seed ); + srcImageInfo.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + srcImageInfo.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); + srcImageInfo.depth = + (size_t)random_log_in_range(16, (int)maxDepth / 32, seed); if (gTestMipmaps) { - imageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(imageInfo.width, imageInfo.height, imageInfo.depth), seed); - imageInfo.rowPitch = imageInfo.width * get_pixel_size( imageInfo.format ); - imageInfo.slicePitch = imageInfo.height * imageInfo.rowPitch; - size = compute_mipmapped_image_size( imageInfo ); + srcImageInfo.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(srcImageInfo.width, + srcImageInfo.height, + srcImageInfo.depth), + seed); + srcImageInfo.rowPitch = srcImageInfo.width + * get_pixel_size(srcImageInfo.format); + srcImageInfo.slicePitch = + srcImageInfo.height * srcImageInfo.rowPitch; + size = compute_mipmapped_image_size(srcImageInfo); size = size*4; } else { - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; - if (gEnablePitch) - { - do { - rowPadding++; - imageInfo.rowPitch = imageInfo.width * pixelSize + rowPadding; - } while ((imageInfo.rowPitch % pixelSize) != 0); - } + if (gEnablePitch) + { + do + { + rowPadding++; + srcImageInfo.rowPitch = + srcImageInfo.width * pixelSize + rowPadding; + } while ((srcImageInfo.rowPitch % pixelSize) != 0); + } - imageInfo.slicePitch = imageInfo.rowPitch * (imageInfo.height + slicePadding); + srcImageInfo.slicePitch = srcImageInfo.rowPitch + * (srcImageInfo.height + slicePadding); - size = (cl_ulong)imageInfo.slicePitch * (cl_ulong)imageInfo.depth * 4 * 4; + size = (cl_ulong)srcImageInfo.slicePitch + * (cl_ulong)srcImageInfo.depth * 4 * 4; } } while( size > maxAllocSize || ( size * 3 ) > memSize ); if( gDebugTrace ) - log_info( " at size %d,%d,%d (pitch %d,%d) out of %d,%d,%d\n", (int)imageInfo.width, (int)imageInfo.height, (int)imageInfo.depth, (int)imageInfo.rowPitch, (int)imageInfo.slicePitch, (int)maxWidth, (int)maxHeight, (int)maxDepth ); - int ret = test_copy_image_3D( context, queue, &imageInfo,seed ); + log_info(" at size %d,%d,%d (pitch %d,%d) out of %d,%d,%d\n", + (int)srcImageInfo.width, (int)srcImageInfo.height, + (int)srcImageInfo.depth, (int)srcImageInfo.rowPitch, + (int)srcImageInfo.slicePitch, (int)maxWidth, + (int)maxHeight, (int)maxDepth); + + dstImageInfo = srcImageInfo; + dstImageInfo.mem_flags = dst_flags; + int ret = test_copy_image_3D(context, queue, &srcImageInfo, + &dstImageInfo, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_copy_3D_2D_array.cpp b/test_conformance/images/clCopyImage/test_copy_3D_2D_array.cpp index 1da1e477..e135af5d 100644 --- a/test_conformance/images/clCopyImage/test_copy_3D_2D_array.cpp +++ b/test_conformance/images/clCopyImage/test_copy_3D_2D_array.cpp @@ -37,12 +37,8 @@ static void set_image_dimensions( image_descriptor *imageInfo, size_t width, siz } while ((imageInfo->rowPitch % pixelSize) != 0); } - imageInfo->slicePitch = imageInfo->rowPitch * (imageInfo->height + slicePadding); - - if (arraySize == 0) - imageInfo->type = CL_MEM_OBJECT_IMAGE3D; - else - imageInfo->type = CL_MEM_OBJECT_IMAGE2D_ARRAY; + imageInfo->slicePitch = + imageInfo->rowPitch * (imageInfo->height + slicePadding); } @@ -227,17 +223,33 @@ int test_copy_image_size_3D_2D_array( cl_context context, cl_command_queue queue } -int test_copy_image_set_3D_2D_array(cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse = false ) +int test_copy_image_set_3D_2D_array( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format) { size_t maxWidth, maxHeight, max3DWidth, max3DHeight, maxDepth, maxArraySize; cl_ulong maxAllocSize, memSize; - image_descriptor srcImageInfo = { 0 }; - image_descriptor dstImageInfo = { 0 }; + const bool reverse = (src_type == CL_MEM_OBJECT_IMAGE2D_ARRAY); + image_descriptor imageInfo3D = { 0 }; + image_descriptor imageInfo2Darray = { 0 }; RandomSeed seed( gRandomSeed ); size_t rowPadding = gEnablePitch ? 256 : 0; size_t slicePadding = gEnablePitch ? 3 : 0; - srcImageInfo.format = dstImageInfo.format = format; + imageInfo3D.format = imageInfo2Darray.format = format; + imageInfo3D.type = CL_MEM_OBJECT_IMAGE3D; + imageInfo2Darray.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; + if (reverse) + { + imageInfo2Darray.mem_flags = src_flags; + imageInfo3D.mem_flags = dst_flags; + } + else + { + imageInfo3D.mem_flags = src_flags; + imageInfo2Darray.mem_flags = dst_flags; + } int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL ); @@ -256,39 +268,79 @@ int test_copy_image_set_3D_2D_array(cl_device_id device, cl_context context, cl_ if( gTestSmallImages ) { - for( dstImageInfo.width = 4; dstImageInfo.width < 17; dstImageInfo.width++ ) + for (imageInfo2Darray.width = 4; imageInfo2Darray.width < 17; + imageInfo2Darray.width++) { - for( dstImageInfo.height = 4; dstImageInfo.height < 13; dstImageInfo.height++ ) + for (imageInfo2Darray.height = 4; imageInfo2Darray.height < 13; + imageInfo2Darray.height++) { - for( dstImageInfo.arraySize = 4; dstImageInfo.arraySize < 9; dstImageInfo.arraySize++ ) + for (imageInfo2Darray.arraySize = 4; + imageInfo2Darray.arraySize < 9; + imageInfo2Darray.arraySize++) { - set_image_dimensions( &dstImageInfo, dstImageInfo.width, dstImageInfo.height, 0, dstImageInfo.arraySize, rowPadding, slicePadding ); - set_image_dimensions( &srcImageInfo, dstImageInfo.width, dstImageInfo.height, dstImageInfo.arraySize, 0, rowPadding, slicePadding ); + set_image_dimensions( + &imageInfo2Darray, imageInfo2Darray.width, + imageInfo2Darray.height, 0, imageInfo2Darray.arraySize, + rowPadding, slicePadding); + set_image_dimensions(&imageInfo3D, imageInfo2Darray.width, + imageInfo2Darray.height, + imageInfo2Darray.arraySize, 0, + rowPadding, slicePadding); if (gTestMipmaps) { - dstImageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE3D; - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, srcImageInfo.depth), seed); - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = srcImageInfo.rowPitch * srcImageInfo.height; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; + imageInfo2Darray.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels( + imageInfo2Darray.width, + imageInfo2Darray.height, 0), + seed); + imageInfo3D.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo3D.width, + imageInfo3D.height, + imageInfo3D.depth), + seed); + imageInfo3D.rowPitch = imageInfo3D.width + * get_pixel_size(imageInfo3D.format); + imageInfo3D.slicePitch = + imageInfo3D.rowPitch * imageInfo3D.height; + imageInfo2Darray.rowPitch = imageInfo2Darray.width + * get_pixel_size(imageInfo2Darray.format); + imageInfo2Darray.slicePitch = + imageInfo2Darray.rowPitch * imageInfo2Darray.height; } if( gDebugTrace ) { if (reverse) - log_info( " at size %d,%d,%d to %d,%d,%d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth ); + log_info(" at size %d,%d,%d to %d,%d,%d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo3D.width, + (int)imageInfo3D.height, + (int)imageInfo3D.depth); else - log_info( " at size %d,%d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info(" at size %d,%d,%d to %d,%d,%d\n", + (int)imageInfo3D.width, + (int)imageInfo3D.height, + (int)imageInfo3D.depth, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } int ret; if( reverse ) - ret = test_copy_image_size_3D_2D_array( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_3D_2D_array( + context, queue, &imageInfo2Darray, &imageInfo3D, + seed); else - ret = test_copy_image_size_3D_2D_array( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_3D_2D_array( + context, queue, &imageInfo3D, &imageInfo2Darray, + seed); if( ret ) return -1; } @@ -303,62 +355,115 @@ int test_copy_image_set_3D_2D_array(cl_device_id device, cl_context context, cl_ size_t sizes2Darray[100][3]; // Try to allocate a bit smaller images because we need the 3D ones as well for the copy. - get_max_sizes(&numbeOfSizes, 100, sizes2Darray, maxWidth, maxHeight, maxDepth, maxArraySize, maxAllocSize/2, memSize/2, CL_MEM_OBJECT_IMAGE2D_ARRAY, srcImageInfo.format); - get_max_sizes(&numbeOfSizes, 100, sizes3D, max3DWidth, max3DHeight, maxDepth, maxArraySize, maxAllocSize/2, memSize/2, CL_MEM_OBJECT_IMAGE3D, dstImageInfo.format); + get_max_sizes(&numbeOfSizes, 100, sizes2Darray, maxWidth, maxHeight, + maxDepth, maxArraySize, maxAllocSize / 2, memSize / 2, + CL_MEM_OBJECT_IMAGE2D_ARRAY, imageInfo3D.format); + get_max_sizes(&numbeOfSizes, 100, sizes3D, max3DWidth, max3DHeight, + maxDepth, maxArraySize, maxAllocSize / 2, memSize / 2, + CL_MEM_OBJECT_IMAGE3D, imageInfo2Darray.format); for( size_t idx = 0; idx < numbeOfSizes; idx++ ) { - set_image_dimensions( &srcImageInfo, sizes3D[ idx ][ 0 ], sizes3D[ idx ][ 1 ], sizes3D[ idx ][ 2 ], 0, rowPadding, slicePadding ); - set_image_dimensions( &dstImageInfo, sizes2Darray[ idx ][ 0 ], sizes2Darray[ idx ][ 1 ], 0, sizes2Darray[ idx ][ 2 ], rowPadding, slicePadding ); + set_image_dimensions(&imageInfo3D, sizes3D[idx][0], sizes3D[idx][1], + sizes3D[idx][2], 0, rowPadding, slicePadding); + set_image_dimensions(&imageInfo2Darray, sizes2Darray[idx][0], + sizes2Darray[idx][1], 0, sizes2Darray[idx][2], + rowPadding, slicePadding); - cl_ulong dstSize = (cl_ulong)dstImageInfo.slicePitch * (cl_ulong)dstImageInfo.arraySize; - cl_ulong srcSize = (cl_ulong)srcImageInfo.slicePitch * (cl_ulong)srcImageInfo.depth; + cl_ulong dstSize = (cl_ulong)imageInfo2Darray.slicePitch + * (cl_ulong)imageInfo2Darray.arraySize; + cl_ulong srcSize = + (cl_ulong)imageInfo3D.slicePitch * (cl_ulong)imageInfo3D.depth; if (gTestMipmaps) { - dstImageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE3D; - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, srcImageInfo.depth), seed); - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = srcImageInfo.rowPitch * srcImageInfo.height; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; - srcSize = 4 * compute_mipmapped_image_size( srcImageInfo ); - dstSize = 4 * compute_mipmapped_image_size( dstImageInfo ); + imageInfo2Darray.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2Darray.width, + imageInfo2Darray.height, 0), + seed); + imageInfo3D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo3D.width, + imageInfo3D.height, + imageInfo3D.depth), + seed); + imageInfo3D.rowPitch = + imageInfo3D.width * get_pixel_size(imageInfo3D.format); + imageInfo3D.slicePitch = + imageInfo3D.rowPitch * imageInfo3D.height; + imageInfo2Darray.rowPitch = imageInfo2Darray.width + * get_pixel_size(imageInfo2Darray.format); + imageInfo2Darray.slicePitch = + imageInfo2Darray.rowPitch * imageInfo2Darray.height; + srcSize = 4 * compute_mipmapped_image_size(imageInfo3D); + dstSize = 4 * compute_mipmapped_image_size(imageInfo2Darray); } if ( ( dstSize < maxAllocSize && dstSize < ( memSize / 3 ) ) && ( srcSize < maxAllocSize && srcSize < ( memSize / 3 ) ) ) { if (reverse) - log_info( "Testing %d x %d x %d to %d x %d x %d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth ); + log_info("Testing %d x %d x %d to %d x %d x %d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); else - log_info( "Testing %d x %d x %d to %d x %d x %d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info("Testing %d x %d x %d to %d x %d x %d\n", + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); if( gDebugTrace ) { if (reverse) - log_info( " at max size %d,%d,%d to %d,%d,%d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth ); + log_info(" at max size %d,%d,%d to %d,%d,%d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo3D.width, + (int)imageInfo3D.height, + (int)imageInfo3D.depth); else - log_info( " at max size %d,%d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info( + " at max size %d,%d,%d to %d,%d,%d\n", + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth, (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } int ret; if( reverse ) - ret = test_copy_image_size_3D_2D_array( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_3D_2D_array( + context, queue, &imageInfo2Darray, &imageInfo3D, seed); else - ret = test_copy_image_size_3D_2D_array( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_3D_2D_array( + context, queue, &imageInfo3D, &imageInfo2Darray, seed); if( ret ) return -1; } else { if (reverse) - log_info("Not testing max size %d x %d x %d x %d to %d x %d due to memory constraints.\n", - (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth); + log_info("Not testing max size %d x %d x %d x %d to %d x " + "%d due to memory constraints.\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); else - log_info("Not testing max size %d x %d x %d to %d x %d x %d due to memory constraints.\n", - (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize); + log_info("Not testing max size %d x %d x %d to %d x %d x " + "%d due to memory constraints.\n", + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } } @@ -372,48 +477,87 @@ int test_copy_image_set_3D_2D_array(cl_device_id device, cl_context context, cl_ // image, the result array, plus offset arrays, will fit in the global ram space do { - dstImageInfo.width = (size_t)random_log_in_range( 16, (int)maxWidth / 32, seed ); - dstImageInfo.height = (size_t)random_log_in_range( 16, (int)maxHeight / 32, seed ); - dstImageInfo.arraySize = (size_t)random_log_in_range( 16, (int)maxArraySize / 32, seed ); - srcImageInfo.width = (size_t)random_log_in_range( 16, (int)max3DWidth / 32, seed ); - srcImageInfo.height = (size_t)random_log_in_range( 16, (int)max3DHeight / 32, seed ); - srcImageInfo.depth = (size_t)random_log_in_range( 16, (int)maxDepth / 32, seed ); + imageInfo2Darray.width = + (size_t)random_log_in_range(16, (int)maxWidth / 32, seed); + imageInfo2Darray.height = + (size_t)random_log_in_range(16, (int)maxHeight / 32, seed); + imageInfo2Darray.arraySize = (size_t)random_log_in_range( + 16, (int)maxArraySize / 32, seed); + imageInfo3D.width = + (size_t)random_log_in_range(16, (int)max3DWidth / 32, seed); + imageInfo3D.height = (size_t)random_log_in_range( + 16, (int)max3DHeight / 32, seed); + imageInfo3D.depth = + (size_t)random_log_in_range(16, (int)maxDepth / 128, seed); if (gTestMipmaps) { - dstImageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; - dstImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(dstImageInfo.width, dstImageInfo.height, 0), seed); - srcImageInfo.type = CL_MEM_OBJECT_IMAGE3D; - srcImageInfo.num_mip_levels = (cl_uint) random_log_in_range(2, (int)compute_max_mip_levels(srcImageInfo.width, srcImageInfo.height, srcImageInfo.depth), seed); - srcImageInfo.rowPitch = srcImageInfo.width * get_pixel_size( srcImageInfo.format ); - srcImageInfo.slicePitch = srcImageInfo.rowPitch * srcImageInfo.height; - dstImageInfo.rowPitch = dstImageInfo.width * get_pixel_size( dstImageInfo.format ); - dstImageInfo.slicePitch = dstImageInfo.rowPitch * dstImageInfo.height; - srcSize = 4 * compute_mipmapped_image_size( srcImageInfo ); - dstSize = 4 * compute_mipmapped_image_size( dstImageInfo ); + imageInfo2Darray.num_mip_levels = + (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo2Darray.width, + imageInfo2Darray.height, + 0), + seed); + imageInfo3D.num_mip_levels = (cl_uint)random_log_in_range( + 2, + (int)compute_max_mip_levels(imageInfo3D.width, + imageInfo3D.height, + imageInfo3D.depth), + seed); + imageInfo3D.rowPitch = + imageInfo3D.width * get_pixel_size(imageInfo3D.format); + imageInfo3D.slicePitch = + imageInfo3D.rowPitch * imageInfo3D.height; + imageInfo2Darray.rowPitch = imageInfo2Darray.width + * get_pixel_size(imageInfo2Darray.format); + imageInfo2Darray.slicePitch = + imageInfo2Darray.rowPitch * imageInfo2Darray.height; + srcSize = 4 * compute_mipmapped_image_size(imageInfo3D); + dstSize = + 4 * compute_mipmapped_image_size(imageInfo2Darray); } else { - set_image_dimensions( &srcImageInfo, srcImageInfo.width, srcImageInfo.height, srcImageInfo.depth, 0, rowPadding, slicePadding ); - set_image_dimensions( &dstImageInfo, dstImageInfo.width, dstImageInfo.height, 0, dstImageInfo.arraySize, rowPadding, slicePadding ); + set_image_dimensions(&imageInfo3D, imageInfo3D.width, + imageInfo3D.height, imageInfo3D.depth, + 0, rowPadding, slicePadding); + set_image_dimensions( + &imageInfo2Darray, imageInfo2Darray.width, + imageInfo2Darray.height, 0, imageInfo2Darray.arraySize, + rowPadding, slicePadding); - srcSize = (cl_ulong)srcImageInfo.slicePitch * (cl_ulong)srcImageInfo.depth * 4; - dstSize = (cl_ulong)dstImageInfo.slicePitch * (cl_ulong)dstImageInfo.arraySize * 4; + srcSize = (cl_ulong)imageInfo3D.slicePitch + * (cl_ulong)imageInfo3D.depth * 4; + dstSize = (cl_ulong)imageInfo2Darray.slicePitch + * (cl_ulong)imageInfo2Darray.arraySize * 4; } } while( srcSize > maxAllocSize || ( srcSize * 3 ) > memSize || dstSize > maxAllocSize || ( dstSize * 3 ) > memSize); if( gDebugTrace ) { if (reverse) - log_info( " at size %d,%d,%d to %d,%d,%d\n", (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize, (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth ); + log_info(" at size %d,%d,%d to %d,%d,%d\n", + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize, + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth); else - log_info( " at size %d,%d,%d to %d,%d,%d\n", (int)srcImageInfo.width, (int)srcImageInfo.height, (int)srcImageInfo.depth, (int)dstImageInfo.width, (int)dstImageInfo.height, (int)dstImageInfo.arraySize ); + log_info(" at size %d,%d,%d to %d,%d,%d\n", + (int)imageInfo3D.width, (int)imageInfo3D.height, + (int)imageInfo3D.depth, + (int)imageInfo2Darray.width, + (int)imageInfo2Darray.height, + (int)imageInfo2Darray.arraySize); } int ret; if( reverse ) - ret = test_copy_image_size_3D_2D_array( context, queue, &dstImageInfo, &srcImageInfo, seed ); + ret = test_copy_image_size_3D_2D_array( + context, queue, &imageInfo2Darray, &imageInfo3D, seed); else - ret = test_copy_image_size_3D_2D_array( context, queue, &srcImageInfo, &dstImageInfo, seed ); + ret = test_copy_image_size_3D_2D_array( + context, queue, &imageInfo3D, &imageInfo2Darray, seed); if( ret ) return -1; } diff --git a/test_conformance/images/clCopyImage/test_loops.cpp b/test_conformance/images/clCopyImage/test_loops.cpp index d9c54854..c5a1ed29 100644 --- a/test_conformance/images/clCopyImage/test_loops.cpp +++ b/test_conformance/images/clCopyImage/test_loops.cpp @@ -15,32 +15,77 @@ // #include "../testBase.h" #include "../common.h" +#include -extern int test_copy_image_set_1D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ); -extern int test_copy_image_set_2D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ); -extern int test_copy_image_set_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ); -extern int test_copy_image_set_1D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ); -extern int test_copy_image_set_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format ); -extern int test_copy_image_set_2D_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse ); -extern int test_copy_image_set_2D_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse ); -extern int test_copy_image_set_3D_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, bool reverse ); -extern int test_copy_image_set_1D_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - cl_image_format *format); -extern int test_copy_image_set_1D_1D_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - cl_image_format *format); -extern int test_copy_image_set_1D_buffer_1D(cl_device_id device, - cl_context context, - cl_command_queue queue, - cl_image_format *format); +extern int +test_copy_image_set_1D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int +test_copy_image_set_2D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int +test_copy_image_set_3D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int test_copy_image_set_1D_array( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int test_copy_image_set_2D_array( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int +test_copy_image_set_2D_3D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_mem_flags src_flags, + cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int test_copy_image_set_2D_2D_array( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int test_copy_image_set_3D_2D_array( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int test_copy_image_set_1D_buffer( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); +extern int test_copy_image_set_1D_1D_buffer( + cl_device_id device, cl_context context, cl_command_queue queue, + cl_mem_flags src_flags, cl_mem_object_type src_type, cl_mem_flags dst_flags, + cl_mem_object_type dst_type, cl_image_format *format); -int test_image_type( cl_device_id device, cl_context context, cl_command_queue queue, MethodsToTest testMethod, cl_mem_flags flags ) +using test_function_t = int (*)(cl_device_id, cl_context, cl_command_queue, + cl_mem_flags, cl_mem_object_type, cl_mem_flags, + cl_mem_object_type, cl_image_format *); + +struct TestConfigs { - const char *name = nullptr; - cl_mem_object_type imageType = 0; + const char *name; + cl_mem_object_type src_type; + cl_mem_flags src_flags; + cl_mem_object_type dst_type; + cl_mem_flags dst_flags; + + TestConfigs(const char *name_, cl_mem_object_type src_type_, + cl_mem_flags src_flags_, cl_mem_object_type dst_type_, + cl_mem_flags dst_flags_) + : name(name_), src_type(src_type_), src_flags(src_flags_), + dst_type(dst_type_), dst_flags(dst_flags_) + {} +}; + +int test_image_type(cl_device_id device, cl_context context, + cl_command_queue queue, MethodsToTest testMethod) +{ + test_function_t test_fn = nullptr; if ( gTestMipmaps ) { @@ -49,138 +94,217 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q log_info( "-----------------------------------------------------\n" ); log_info( "This device does not support cl_khr_mipmap_image.\nSkipping mipmapped image test. \n" ); log_info( "-----------------------------------------------------\n\n" ); - return 0; + return TEST_SKIPPED_ITSELF; } } + std::vector test_configs; switch (testMethod) { case k1D: - name = "1D -> 1D"; - imageType = CL_MEM_OBJECT_IMAGE1D; + test_configs.emplace_back( + "1D -> 1D", CL_MEM_OBJECT_IMAGE1D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE1D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_1D; break; case k2D: - name = "2D -> 2D"; - imageType = CL_MEM_OBJECT_IMAGE2D; + test_configs.emplace_back( + "2D -> 2D", CL_MEM_OBJECT_IMAGE2D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_2D; break; case k3D: - name = "3D -> 3D"; - imageType = CL_MEM_OBJECT_IMAGE3D; + test_configs.emplace_back( + "3D -> 3D", CL_MEM_OBJECT_IMAGE3D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE3D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_3D; break; case k1DArray: - name = "1D array -> 1D array"; - imageType = CL_MEM_OBJECT_IMAGE1D_ARRAY; + test_configs.emplace_back( + "1D array -> 1D array", CL_MEM_OBJECT_IMAGE1D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE1D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_1D_array; break; case k2DArray: - name = "2D array -> 2D array"; - imageType = CL_MEM_OBJECT_IMAGE2D_ARRAY; + test_configs.emplace_back( + "2D array -> 2D array", CL_MEM_OBJECT_IMAGE2D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_2D_array; break; case k2DTo3D: - name = "2D -> 3D"; - imageType = CL_MEM_OBJECT_IMAGE3D; + test_configs.emplace_back( + "2D -> 3D", CL_MEM_OBJECT_IMAGE2D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE3D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_2D_3D; break; case k3DTo2D: - name = "3D -> 2D"; - imageType = CL_MEM_OBJECT_IMAGE3D; + test_configs.emplace_back( + "3D -> 2D", CL_MEM_OBJECT_IMAGE3D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_2D_3D; break; case k2DArrayTo2D: - name = "2D array -> 2D"; - imageType = CL_MEM_OBJECT_IMAGE2D_ARRAY; + test_configs.emplace_back( + "2D array -> 2D", CL_MEM_OBJECT_IMAGE2D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_2D_2D_array; break; case k2DTo2DArray: - name = "2D -> 2D array"; - imageType = CL_MEM_OBJECT_IMAGE2D_ARRAY; + test_configs.emplace_back( + "2D -> 2D array", CL_MEM_OBJECT_IMAGE2D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_2D_2D_array; break; case k2DArrayTo3D: - name = "2D array -> 3D"; - imageType = CL_MEM_OBJECT_IMAGE3D; + test_configs.emplace_back( + "2D array -> 3D", CL_MEM_OBJECT_IMAGE2D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE3D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_3D_2D_array; break; case k3DTo2DArray: - name = "3D -> 2D array"; - imageType = CL_MEM_OBJECT_IMAGE3D; + test_configs.emplace_back( + "3D -> 2D array", CL_MEM_OBJECT_IMAGE3D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D_ARRAY, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_3D_2D_array; break; case k1DBuffer: - name = "1D buffer -> 1D buffer"; - imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER; + test_configs.emplace_back( + "1D buffer -> 1D buffer", CL_MEM_OBJECT_IMAGE1D_BUFFER, + CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE1D_BUFFER, + CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_1D_buffer; break; case k1DTo1DBuffer: - name = "1D -> 1D buffer"; - imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER; + test_configs.emplace_back( + "1D -> 1D buffer", CL_MEM_OBJECT_IMAGE1D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE1D_BUFFER, CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_1D_1D_buffer; break; case k1DBufferTo1D: - name = "1D buffer -> 1D"; - imageType = CL_MEM_OBJECT_IMAGE1D_BUFFER; + test_configs.emplace_back( + "1D buffer -> 1D", CL_MEM_OBJECT_IMAGE1D_BUFFER, + CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE1D, + gEnablePitch ? CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY + : CL_MEM_READ_ONLY); + test_fn = test_copy_image_set_1D_1D_buffer; break; } - if(gTestMipmaps) - log_info( "Running mipmapped %s tests...\n", name ); - else - log_info( "Running %s tests...\n", name ); int ret = 0; - - // Grab the list of supported image formats for integer reads - std::vector formatList; - if (get_format_list(context, imageType, formatList, flags)) return -1; - - std::vector filterFlags(formatList.size(), false); - filter_formats(formatList, filterFlags, nullptr); - - // Run the format list - for (unsigned int i = 0; i < formatList.size(); i++) + for (const auto &test_config : test_configs) { - int test_return = 0; - if( filterFlags[i] ) + if (gTestMipmaps) + log_info("Running mipmapped %s tests...\n", test_config.name); + else + log_info("Running %s tests...\n", test_config.name); + + // Grab the list of supported image formats for integer reads + std::vector formatList; { - continue; + std::vector srcFormatList; + std::vector dstFormatList; + if (get_format_list(context, test_config.src_type, srcFormatList, + test_config.src_flags)) + return TEST_FAIL; + if (get_format_list(context, test_config.dst_type, dstFormatList, + test_config.dst_flags)) + return TEST_FAIL; + + for (auto src_format : srcFormatList) + { + const bool src_format_in_dst = + std::find_if(dstFormatList.begin(), dstFormatList.end(), + [src_format](cl_image_format fmt) { + return src_format.image_channel_data_type + == fmt.image_channel_data_type + && src_format.image_channel_order + == fmt.image_channel_order; + }) + != dstFormatList.end(); + if (src_format_in_dst) + { + formatList.push_back(src_format); + } + } } - print_header( &formatList[ i ], false ); + std::vector filterFlags(formatList.size(), false); + filter_formats(formatList, filterFlags, nullptr); - gTestCount++; + // Run the format list + for (unsigned int i = 0; i < formatList.size(); i++) + { + int test_return = 0; + if (filterFlags[i]) + { + continue; + } - if( testMethod == k1D ) - test_return = test_copy_image_set_1D( device, context, queue, &formatList[ i ] ); - else if( testMethod == k2D ) - test_return = test_copy_image_set_2D( device, context, queue, &formatList[ i ] ); - else if( testMethod == k3D ) - test_return = test_copy_image_set_3D( device, context, queue,&formatList[ i ] ); - else if( testMethod == k1DArray ) - test_return = test_copy_image_set_1D_array( device, context, queue, &formatList[ i ] ); - else if( testMethod == k2DArray ) - test_return = test_copy_image_set_2D_array( device, context, queue, &formatList[ i ] ); - else if( testMethod == k2DTo3D ) - test_return = test_copy_image_set_2D_3D( device, context, queue, &formatList[ i ], false ); - else if( testMethod == k3DTo2D ) - test_return = test_copy_image_set_2D_3D( device, context, queue, &formatList[ i ], true ); - else if( testMethod == k2DArrayTo2D) - test_return = test_copy_image_set_2D_2D_array( device, context, queue, &formatList[ i ], true); - else if( testMethod == k2DTo2DArray) - test_return = test_copy_image_set_2D_2D_array( device, context, queue, &formatList[ i ], false); - else if( testMethod == k2DArrayTo3D) - test_return = test_copy_image_set_3D_2D_array( device, context, queue, &formatList[ i ], true); - else if( testMethod == k3DTo2DArray) - test_return = test_copy_image_set_3D_2D_array( device, context, queue, &formatList[ i ], false); - else if (testMethod == k1DBuffer) - test_return = test_copy_image_set_1D_buffer(device, context, queue, - &formatList[i]); - else if (testMethod == k1DBufferTo1D) - test_return = test_copy_image_set_1D_buffer_1D( - device, context, queue, &formatList[i]); - else if (testMethod == k1DTo1DBuffer) - test_return = test_copy_image_set_1D_1D_buffer( - device, context, queue, &formatList[i]); + print_header(&formatList[i], false); + gTestCount++; - if (test_return) { - gFailCount++; - log_error( "FAILED: " ); - print_header( &formatList[ i ], true ); - log_info( "\n" ); + test_return = test_fn(device, context, queue, test_config.src_flags, + test_config.src_type, test_config.dst_flags, + test_config.dst_type, &formatList[i]); + + if (test_return) + { + gFailCount++; + log_error("FAILED: "); + print_header(&formatList[i], true); + log_info("\n"); + } + + ret += test_return; } - - ret += test_return; } return ret; @@ -188,11 +312,7 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q int test_image_set( cl_device_id device, cl_context context, cl_command_queue queue, MethodsToTest testMethod ) { - int ret = 0; - - ret += test_image_type( device, context, queue, testMethod, CL_MEM_READ_ONLY ); - - return ret; + return test_image_type(device, context, queue, testMethod); } diff --git a/test_conformance/images/clFillImage/main.cpp b/test_conformance/images/clFillImage/main.cpp index 62e62c63..d5f565bd 100644 --- a/test_conformance/images/clFillImage/main.cpp +++ b/test_conformance/images/clFillImage/main.cpp @@ -32,39 +32,22 @@ extern int test_image_set( cl_device_id device, cl_context context, cl_command_q static void printUsage( const char *execName ); -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) -{ - return test_image_set(device, context, queue, k1D); -} -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) -{ - return test_image_set(device, context, queue, k2D); -} -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) -{ - return test_image_set(device, context, queue, k3D); -} -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return test_image_set(device, context, queue, k1D); } +REGISTER_TEST(2D) { return test_image_set(device, context, queue, k2D); } +REGISTER_TEST(3D) { return test_image_set(device, context, queue, k3D); } +REGISTER_TEST(1Darray) { return test_image_set(device, context, queue, k1DArray); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return test_image_set(device, context, queue, k2DArray); } -int test_1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1Dbuffer) { return test_image_set(device, context, queue, k1DBuffer); } -test_definition test_list[] = { - ADD_TEST(1D), ADD_TEST(2D), ADD_TEST(3D), - ADD_TEST(1Darray), ADD_TEST(2Darray), ADD_TEST(1Dbuffer), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -126,8 +109,10 @@ int main(int argc, const char *argv[]) if ( gTestSmallImages ) log_info( "Note: Using small test images\n" ); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); free(argList); return ret; @@ -153,9 +138,9 @@ static void printUsage( const char *execName ) log_info( "\tuse_pitches - Enables row and slice pitches\n" ); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } log_info( "\n" ); log_info( "You may also use appropriate CL_ channel type and ordering constants.\n" ); diff --git a/test_conformance/images/clFillImage/test_fill_1D.cpp b/test_conformance/images/clFillImage/test_fill_1D.cpp index b1550bf3..ad19b52d 100644 --- a/test_conformance/images/clFillImage/test_fill_1D.cpp +++ b/test_conformance/images/clFillImage/test_fill_1D.cpp @@ -58,7 +58,9 @@ int test_fill_image_size_1D( cl_context context, cl_command_queue queue, image_d } -int test_fill_image_set_1D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ) +int test_fill_image_set_1D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_image_format *format, + cl_mem_flags mem_flags, ExplicitType outputType) { size_t maxWidth; cl_ulong maxAllocSize, memSize; @@ -71,6 +73,7 @@ int test_fill_image_set_1D( cl_device_id device, cl_context context, cl_command_ memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE1D; imageInfo.format = format; + imageInfo.mem_flags = mem_flags; pixelSize = get_pixel_size( imageInfo.format ); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); diff --git a/test_conformance/images/clFillImage/test_fill_1D_array.cpp b/test_conformance/images/clFillImage/test_fill_1D_array.cpp index be32ec6a..1c88f3da 100644 --- a/test_conformance/images/clFillImage/test_fill_1D_array.cpp +++ b/test_conformance/images/clFillImage/test_fill_1D_array.cpp @@ -60,7 +60,11 @@ int test_fill_image_size_1D_array( cl_context context, cl_command_queue queue, i } -int test_fill_image_set_1D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ) +int test_fill_image_set_1D_array(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType) { size_t maxWidth, maxArraySize; cl_ulong maxAllocSize, memSize; @@ -73,6 +77,7 @@ int test_fill_image_set_1D_array( cl_device_id device, cl_context context, cl_co memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE1D_ARRAY; imageInfo.format = format; + imageInfo.mem_flags = mem_flags; pixelSize = get_pixel_size( imageInfo.format ); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); diff --git a/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp index dad389ae..2e8790c1 100644 --- a/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp +++ b/test_conformance/images/clFillImage/test_fill_1D_buffer.cpp @@ -71,6 +71,7 @@ int test_fill_image_size_1D_buffer(cl_context context, cl_command_queue queue, int test_fill_image_set_1D_buffer(cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, + cl_mem_flags mem_flags, ExplicitType outputType) { size_t maxWidth; @@ -84,6 +85,7 @@ int test_fill_image_set_1D_buffer(cl_device_id device, cl_context context, memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE1D_BUFFER; imageInfo.format = format; + imageInfo.mem_flags = mem_flags; pixelSize = get_pixel_size(imageInfo.format); int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, diff --git a/test_conformance/images/clFillImage/test_fill_2D.cpp b/test_conformance/images/clFillImage/test_fill_2D.cpp index e941abcf..93675485 100644 --- a/test_conformance/images/clFillImage/test_fill_2D.cpp +++ b/test_conformance/images/clFillImage/test_fill_2D.cpp @@ -60,7 +60,9 @@ int test_fill_image_size_2D( cl_context context, cl_command_queue queue, image_d } -int test_fill_image_set_2D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ) +int test_fill_image_set_2D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_image_format *format, + cl_mem_flags mem_flags, ExplicitType outputType) { size_t maxWidth, maxHeight; cl_ulong maxAllocSize, memSize; @@ -73,6 +75,7 @@ int test_fill_image_set_2D( cl_device_id device, cl_context context, cl_command_ memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE2D; imageInfo.format = format; + imageInfo.mem_flags = mem_flags; pixelSize = get_pixel_size( imageInfo.format ); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); diff --git a/test_conformance/images/clFillImage/test_fill_2D_array.cpp b/test_conformance/images/clFillImage/test_fill_2D_array.cpp index 38196cfc..12024e6e 100644 --- a/test_conformance/images/clFillImage/test_fill_2D_array.cpp +++ b/test_conformance/images/clFillImage/test_fill_2D_array.cpp @@ -62,7 +62,11 @@ static int test_fill_image_2D_array( cl_context context, cl_command_queue queue, } -int test_fill_image_set_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ) +int test_fill_image_set_2D_array(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType) { size_t maxWidth, maxHeight, maxArraySize; cl_ulong maxAllocSize, memSize; @@ -76,6 +80,7 @@ int test_fill_image_set_2D_array( cl_device_id device, cl_context context, cl_co memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE2D_ARRAY; imageInfo.format = format; + imageInfo.mem_flags = mem_flags; pixelSize = get_pixel_size( imageInfo.format ); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); diff --git a/test_conformance/images/clFillImage/test_fill_3D.cpp b/test_conformance/images/clFillImage/test_fill_3D.cpp index 0b8e4e58..75067e14 100644 --- a/test_conformance/images/clFillImage/test_fill_3D.cpp +++ b/test_conformance/images/clFillImage/test_fill_3D.cpp @@ -62,7 +62,9 @@ int test_fill_image_3D( cl_context context, cl_command_queue queue, image_descri } -int test_fill_image_set_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ) +int test_fill_image_set_3D(cl_device_id device, cl_context context, + cl_command_queue queue, cl_image_format *format, + cl_mem_flags mem_flags, ExplicitType outputType) { size_t maxWidth, maxHeight, maxDepth; cl_ulong maxAllocSize, memSize; @@ -76,6 +78,7 @@ int test_fill_image_set_3D( cl_device_id device, cl_context context, cl_command_ memset(&imageInfo, 0x0, sizeof(image_descriptor)); imageInfo.type = CL_MEM_OBJECT_IMAGE3D; imageInfo.format = format; + imageInfo.mem_flags = mem_flags; pixelSize = get_pixel_size( imageInfo.format ); int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL ); diff --git a/test_conformance/images/clFillImage/test_loops.cpp b/test_conformance/images/clFillImage/test_loops.cpp index 95677aec..cb1e1a3e 100644 --- a/test_conformance/images/clFillImage/test_loops.cpp +++ b/test_conformance/images/clFillImage/test_loops.cpp @@ -18,19 +18,38 @@ extern int gTypesToTest; -extern int test_fill_image_set_1D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ); -extern int test_fill_image_set_2D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ); -extern int test_fill_image_set_3D( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ); -extern int test_fill_image_set_1D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ); -extern int test_fill_image_set_2D_array( cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, ExplicitType outputType ); -extern int test_fill_image_set_1D_buffer(cl_device_id device, - cl_context context, - cl_command_queue queue, - cl_image_format *format, - ExplicitType outputType); +extern int test_fill_image_set_1D(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType); +extern int test_fill_image_set_2D(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType); +extern int test_fill_image_set_3D(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType); +extern int test_fill_image_set_1D_array(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType); +extern int test_fill_image_set_2D_array(cl_device_id device, cl_context context, + cl_command_queue queue, + cl_image_format *format, + cl_mem_flags mem_flags, + ExplicitType outputType); +extern int +test_fill_image_set_1D_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, cl_image_format *format, + cl_mem_flags mem_flags, ExplicitType outputType); typedef int (*test_func)(cl_device_id device, cl_context context, cl_command_queue queue, cl_image_format *format, - ExplicitType outputType); + cl_mem_flags mem_flags, ExplicitType outputType); int test_image_type( cl_device_id device, cl_context context, cl_command_queue queue, MethodsToTest testMethod, cl_mem_flags flags ) { @@ -105,7 +124,7 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q gTestCount++; int test_return = - test_fn(device, context, queue, &formatList[i], + test_fn(device, context, queue, &formatList[i], flags, test.explicitType); if (test_return) { @@ -128,8 +147,12 @@ int test_image_type( cl_device_id device, cl_context context, cl_command_queue q int test_image_set( cl_device_id device, cl_context context, cl_command_queue queue, MethodsToTest testMethod ) { int ret = 0; - - ret += test_image_type( device, context, queue, testMethod, CL_MEM_READ_ONLY ); + cl_mem_flags flags = CL_MEM_READ_ONLY; + if (gEnablePitch && testMethod != k1DBuffer) + { + flags |= CL_MEM_USE_HOST_PTR; + } + ret += test_image_type(device, context, queue, testMethod, flags); return ret; } diff --git a/test_conformance/images/clGetInfo/main.cpp b/test_conformance/images/clGetInfo/main.cpp index 933eb00f..abca3490 100644 --- a/test_conformance/images/clGetInfo/main.cpp +++ b/test_conformance/images/clGetInfo/main.cpp @@ -28,15 +28,15 @@ cl_channel_order gChannelOrderToUse = (cl_channel_order)-1; extern int test_image_set( cl_device_id device, cl_context context, cl_mem_object_type image_type ); static void printUsage( const char *execName ); -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return test_image_set( device, context, CL_MEM_OBJECT_IMAGE1D ); } -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2D) { return test_image_set( device, context, CL_MEM_OBJECT_IMAGE2D ); } -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3D) { if( checkFor3DImageSupport( device ) ) { @@ -46,27 +46,19 @@ int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int return test_image_set( device, context, CL_MEM_OBJECT_IMAGE3D ); } -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1Darray) { return test_image_set( device, context, CL_MEM_OBJECT_IMAGE1D_ARRAY ); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return test_image_set( device, context, CL_MEM_OBJECT_IMAGE2D_ARRAY ); } -int test_1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1Dbuffer) { return test_image_set(device, context, CL_MEM_OBJECT_IMAGE1D_BUFFER); } -test_definition test_list[] = { - ADD_TEST(1D), ADD_TEST(2D), ADD_TEST(3D), - ADD_TEST(1Darray), ADD_TEST(2Darray), ADD_TEST(1Dbuffer), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -110,8 +102,10 @@ int main(int argc, const char *argv[]) if( gTestSmallImages ) log_info( "Note: Using small test images\n" ); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); free(argList); return ret; @@ -133,8 +127,8 @@ static void printUsage( const char *execName ) log_info( "\trandomize - Seed random number generator (default do not seed random number generator)\n" ); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } } diff --git a/test_conformance/images/clReadWriteImage/main.cpp b/test_conformance/images/clReadWriteImage/main.cpp index 642b8a57..8723b5e9 100644 --- a/test_conformance/images/clReadWriteImage/main.cpp +++ b/test_conformance/images/clReadWriteImage/main.cpp @@ -31,39 +31,31 @@ static void printUsage( const char *execName ); extern int test_image_set( cl_device_id device, cl_context context, cl_command_queue queue, cl_mem_object_type image_type ); -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE1D ); } -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D ); } -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE3D ); } -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1Darray) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE1D_ARRAY ); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D_ARRAY ); } -int test_1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1Dbuffer) { return test_image_set(device, context, queue, CL_MEM_OBJECT_IMAGE1D_BUFFER); } -test_definition test_list[] = { - ADD_TEST(1D), ADD_TEST(2D), ADD_TEST(3D), - ADD_TEST(1Darray), ADD_TEST(2Darray), ADD_TEST(1Dbuffer), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -114,8 +106,10 @@ int main(int argc, const char *argv[]) if( gTestSmallImages ) log_info( "Note: Using small test images\n" ); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); free(argList); return ret; @@ -137,8 +131,8 @@ static void printUsage( const char *execName ) log_info( "\trandomize - Uses random seed\n" ); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } } diff --git a/test_conformance/images/common.cpp b/test_conformance/images/common.cpp index f11a0215..95845b72 100644 --- a/test_conformance/images/common.cpp +++ b/test_conformance/images/common.cpp @@ -30,6 +30,9 @@ cl_channel_type floatFormats[] = { CL_SNORM_INT16, CL_FLOAT, CL_HALF_FLOAT, + CL_UNORM_INT10X6_EXT, + CL_UNORM_INT12X4_EXT, + CL_UNORM_INT14X2_EXT, (cl_channel_type)-1, }; @@ -41,9 +44,8 @@ cl_channel_type intFormats[] = { }; cl_channel_type uintFormats[] = { - CL_UNSIGNED_INT8, - CL_UNSIGNED_INT16, - CL_UNSIGNED_INT32, + CL_UNSIGNED_INT8, CL_UNSIGNED_INT16, CL_UNSIGNED_INT32, + CL_UNSIGNED_INT10X6_EXT, CL_UNSIGNED_INT12X4_EXT, CL_UNSIGNED_INT14X2_EXT, (cl_channel_type)-1, }; @@ -173,7 +175,6 @@ clMemWrapper create_image(cl_context context, cl_command_queue queue, { cl_mem img; cl_image_desc imageDesc; - cl_mem_flags mem_flags = CL_MEM_READ_ONLY; void *host_ptr = nullptr; bool is_host_ptr_aligned = false; @@ -310,21 +311,17 @@ clMemWrapper create_image(cl_context context, cl_command_queue queue, imageInfo->depth * imageInfo->slicePitch); return nullptr; } - if (imageInfo->type != CL_MEM_OBJECT_IMAGE1D_BUFFER) - { - mem_flags = CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR; - } } if (imageInfo->type != CL_MEM_OBJECT_IMAGE1D_BUFFER) { - img = clCreateImage(context, mem_flags, imageInfo->format, &imageDesc, - host_ptr, error); + img = clCreateImage(context, imageInfo->mem_flags, imageInfo->format, + &imageDesc, host_ptr, error); } else { - img = clCreateImage(context, mem_flags, imageInfo->format, &imageDesc, - nullptr, error); + img = clCreateImage(context, imageInfo->mem_flags, imageInfo->format, + &imageDesc, nullptr, error); } if (enable_pitch) diff --git a/test_conformance/images/kernel_image_methods/main.cpp b/test_conformance/images/kernel_image_methods/main.cpp index a0a6fc57..0b6f29fe 100644 --- a/test_conformance/images/kernel_image_methods/main.cpp +++ b/test_conformance/images/kernel_image_methods/main.cpp @@ -31,39 +31,31 @@ extern int test_image_set( cl_device_id device, cl_context context, cl_command_q static void printUsage( const char *execName ); -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE1D ); } -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D ); } -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE3D ); } -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1Darray) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE1D_ARRAY ); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D_ARRAY ); } -int test_1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1Dbuffer) { return test_image_set(device, context, queue, CL_MEM_OBJECT_IMAGE1D_BUFFER); } -test_definition test_list[] = { - ADD_TEST(1D), ADD_TEST(2D), ADD_TEST(3D), - ADD_TEST(1Darray), ADD_TEST(2Darray), ADD_TEST(1Dbuffer), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -113,8 +105,10 @@ int main(int argc, const char *argv[]) if( gTestSmallImages ) log_info( "Note: Using small test images\n" ); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); free(argList); return ret; @@ -134,8 +128,8 @@ static void printUsage( const char *execName ) log_info( "\trandomize - Uses random seed\n" ); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } } diff --git a/test_conformance/images/kernel_read_write/main.cpp b/test_conformance/images/kernel_read_write/main.cpp index 8c4f5557..3a3e13f3 100644 --- a/test_conformance/images/kernel_read_write/main.cpp +++ b/test_conformance/images/kernel_read_write/main.cpp @@ -264,140 +264,82 @@ static int doTest( cl_device_id device, cl_context context, cl_command_queue que return ret; } -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return doTest( device, context, queue, CL_MEM_OBJECT_IMAGE1D ); } -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2D) { return doTest( device, context, queue, CL_MEM_OBJECT_IMAGE2D ); } -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3D) { return doTest( device, context, queue, CL_MEM_OBJECT_IMAGE3D ); } -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1Darray) { return doTest( device, context, queue, CL_MEM_OBJECT_IMAGE1D_ARRAY ); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return doTest( device, context, queue, CL_MEM_OBJECT_IMAGE2D_ARRAY ); } -int test_cl_image_requirements_size_ext_negative(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(cl_image_requirements_size_ext_negative, Version(3, 0)) { return cl_image_requirements_size_ext_negative(device, context, queue); } -int test_cl_image_requirements_size_ext_consistency(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(cl_image_requirements_size_ext_consistency, Version(3, 0)) { return cl_image_requirements_size_ext_consistency(device, context, queue); } -int test_clGetImageRequirementsInfoEXT_negative(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(clGetImageRequirementsInfoEXT_negative, Version(3, 0)) { return clGetImageRequirementsInfoEXT_negative(device, context, queue); } -int test_cl_image_requirements_max_val_ext_negative(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(cl_image_requirements_max_val_ext_negative, Version(3, 0)) { return cl_image_requirements_max_val_ext_negative(device, context, queue); } -int test_cl_image_requirements_max_val_ext_positive(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(cl_image_requirements_max_val_ext_positive, Version(3, 0)) { return cl_image_requirements_max_val_ext_positive(device, context, queue); } -int test_image2d_from_buffer_positive(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST_VERSION(image2d_from_buffer_positive, Version(3, 0)) { return image2d_from_buffer_positive(device, context, queue); } -int test_memInfo_image_from_buffer_positive(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(memInfo_image_from_buffer_positive, Version(3, 0)) { return memInfo_image_from_buffer_positive(device, context, queue); } -int test_imageInfo_image_from_buffer_positive(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(imageInfo_image_from_buffer_positive, Version(3, 0)) { return imageInfo_image_from_buffer_positive(device, context, queue); } -int test_image_from_buffer_alignment_negative(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(image_from_buffer_alignment_negative, Version(3, 0)) { return image_from_buffer_alignment_negative(device, context, queue); } -int test_image_from_small_buffer_negative(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(image_from_small_buffer_negative, Version(3, 0)) { return image_from_small_buffer_negative(device, context, queue); } -int test_image_from_buffer_fill_positive(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(image_from_buffer_fill_positive, Version(3, 0)) { return image_from_buffer_fill_positive(device, context, queue); } -int test_image_from_buffer_read_positive(cl_device_id device, - cl_context context, - cl_command_queue queue, - int num_elements) +REGISTER_TEST_VERSION(image_from_buffer_read_positive, Version(3, 0)) { return image_from_buffer_read_positive(device, context, queue); } -int test_cl_ext_image_raw10_raw12(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST_VERSION(cl_ext_image_raw10_raw12, Version(1, 2)) { return ext_image_raw10_raw12(device, context, queue); } -test_definition test_list[] = { - ADD_TEST(1D), - ADD_TEST(2D), - ADD_TEST(3D), - ADD_TEST(1Darray), - ADD_TEST(2Darray), - ADD_TEST_VERSION(cl_image_requirements_size_ext_negative, Version(3, 0)), - ADD_TEST_VERSION(cl_image_requirements_size_ext_consistency, Version(3, 0)), - ADD_TEST_VERSION(clGetImageRequirementsInfoEXT_negative, Version(3, 0)), - ADD_TEST_VERSION(cl_image_requirements_max_val_ext_negative, Version(3, 0)), - ADD_TEST_VERSION(cl_image_requirements_max_val_ext_positive, Version(3, 0)), - ADD_TEST_VERSION(image2d_from_buffer_positive, Version(3, 0)), - ADD_TEST_VERSION(memInfo_image_from_buffer_positive, Version(3, 0)), - ADD_TEST_VERSION(imageInfo_image_from_buffer_positive, Version(3, 0)), - ADD_TEST_VERSION(image_from_buffer_alignment_negative, Version(3, 0)), - ADD_TEST_VERSION(image_from_small_buffer_negative, Version(3, 0)), - ADD_TEST_VERSION(image_from_buffer_fill_positive, Version(3, 0)), - ADD_TEST_VERSION(image_from_buffer_read_positive, Version(3, 0)), - ADD_TEST_VERSION(cl_ext_image_raw10_raw12, Version(1, 2)), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -532,8 +474,10 @@ int main(int argc, const char *argv[]) FPU_mode_type oldMode; DisableFTZ(&oldMode); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); // Restore FP state before leaving RestoreFPState(&oldMode); @@ -593,8 +537,8 @@ static void printUsage( const char *execName ) log_info( "\ttest_mipmaps - Enables mipmapped images\n"); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } } diff --git a/test_conformance/images/kernel_read_write/test_common.cpp b/test_conformance/images/kernel_read_write/test_common.cpp index 7ed280b0..245de3ac 100644 --- a/test_conformance/images/kernel_read_write/test_common.cpp +++ b/test_conformance/images/kernel_read_write/test_common.cpp @@ -2152,8 +2152,13 @@ int filter_rounding_errors(int forceCorrectlyRoundedWrites, || imageInfo->format->image_channel_data_type == CL_SNORM_INT8 || imageInfo->format->image_channel_data_type == CL_SNORM_INT16 || imageInfo->format->image_channel_data_type == CL_UNORM_SHORT_555 + || imageInfo->format->image_channel_data_type == CL_UNORM_SHORT_565 || imageInfo->format->image_channel_data_type - == CL_UNORM_SHORT_565)) + == CL_UNORM_INT10X6_EXT + || imageInfo->format->image_channel_data_type + == CL_UNORM_INT12X4_EXT + || imageInfo->format->image_channel_data_type + == CL_UNORM_INT14X2_EXT)) { if (!(fabsf(errors[0]) > 0.6f) && !(fabsf(errors[1]) > 0.6f) && !(fabsf(errors[2]) > 0.6f) && !(fabsf(errors[3]) > 0.6f)) diff --git a/test_conformance/images/samplerlessReads/main.cpp b/test_conformance/images/samplerlessReads/main.cpp index a8eb3e36..95945c9c 100644 --- a/test_conformance/images/samplerlessReads/main.cpp +++ b/test_conformance/images/samplerlessReads/main.cpp @@ -41,39 +41,31 @@ static void printUsage( const char *execName ); extern int test_image_set( cl_device_id device, cl_context context, cl_command_queue queue, cl_mem_object_type imageType ); -int test_1D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1D) { return test_image_set(device, context, queue, CL_MEM_OBJECT_IMAGE1D); } -int test_1Dbuffer(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(1Dbuffer) { return test_image_set(device, context, queue, CL_MEM_OBJECT_IMAGE1D_BUFFER); } -int test_2D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D ); } -int test_3D(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(3D) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE3D ); } -int test_1Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(1Darray) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE1D_ARRAY ); } -int test_2Darray(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(2Darray) { return test_image_set( device, context, queue, CL_MEM_OBJECT_IMAGE2D_ARRAY ); } -test_definition test_list[] = { - ADD_TEST(1D), ADD_TEST(1Dbuffer), ADD_TEST(2D), - ADD_TEST(3D), ADD_TEST(1Darray), ADD_TEST(2Darray), -}; - -const int test_num = ARRAY_SIZE( test_list ); - int main(int argc, const char *argv[]) { cl_channel_type chanType; @@ -152,8 +144,10 @@ int main(int argc, const char *argv[]) FPU_mode_type oldMode; DisableFTZ(&oldMode); - int ret = runTestHarnessWithCheck(argCount, argList, test_num, test_list, - false, 0, verifyImageSupport); + int ret = runTestHarnessWithCheck( + argCount, argList, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0, + verifyImageSupport); // Restore FP state before leaving RestoreFPState(&oldMode); @@ -187,8 +181,8 @@ static void printUsage( const char *execName ) log_info( "\tuse_pitches - Enables row and slice pitches\n" ); log_info( "\n" ); log_info( "Test names:\n" ); - for( int i = 0; i < test_num; i++ ) + for (size_t i = 0; i < test_registry::getInstance().num_tests(); i++) { - log_info( "\t%s\n", test_list[i].name ); + log_info("\t%s\n", test_registry::getInstance().definitions()[i].name); } } diff --git a/test_conformance/integer_ops/main.cpp b/test_conformance/integer_ops/main.cpp index 59840de7..32849af7 100644 --- a/test_conformance/integer_ops/main.cpp +++ b/test_conformance/integer_ops/main.cpp @@ -17,142 +17,13 @@ #include #include -#include "procs.h" #include "harness/testHarness.h" +#include "harness/mt19937.h" #if !defined(_WIN32) #include #endif -test_definition test_list[] = { - ADD_TEST(integer_clz), - ADD_TEST_VERSION(integer_ctz, Version(2, 0)), - ADD_TEST(integer_hadd), - ADD_TEST(integer_rhadd), - ADD_TEST(integer_mul_hi), - ADD_TEST(integer_rotate), - ADD_TEST(integer_clamp), - ADD_TEST(integer_mad_sat), - ADD_TEST(integer_mad_hi), - ADD_TEST(integer_min), - ADD_TEST(integer_max), - ADD_TEST(integer_upsample), - - ADD_TEST(integer_abs), - ADD_TEST(integer_abs_diff), - ADD_TEST(integer_add_sat), - ADD_TEST(integer_sub_sat), - - ADD_TEST(integer_addAssign), - ADD_TEST(integer_subtractAssign), - ADD_TEST(integer_multiplyAssign), - ADD_TEST(integer_divideAssign), - ADD_TEST(integer_moduloAssign), - ADD_TEST(integer_andAssign), - ADD_TEST(integer_orAssign), - ADD_TEST(integer_exclusiveOrAssign), - - ADD_TEST(unary_ops_increment), - ADD_TEST(unary_ops_decrement), - ADD_TEST(unary_ops_full), - - ADD_TEST(integer_mul24), - ADD_TEST(integer_mad24), - - ADD_TEST(extended_bit_ops_extract), - ADD_TEST(extended_bit_ops_insert), - ADD_TEST(extended_bit_ops_reverse), - - ADD_TEST(long_math), - ADD_TEST(long_logic), - ADD_TEST(long_shift), - ADD_TEST(long_compare), - - ADD_TEST(ulong_math), - ADD_TEST(ulong_logic), - ADD_TEST(ulong_shift), - ADD_TEST(ulong_compare), - - ADD_TEST(int_math), - ADD_TEST(int_logic), - ADD_TEST(int_shift), - ADD_TEST(int_compare), - - ADD_TEST(uint_math), - ADD_TEST(uint_logic), - ADD_TEST(uint_shift), - ADD_TEST(uint_compare), - - ADD_TEST(short_math), - ADD_TEST(short_logic), - ADD_TEST(short_shift), - ADD_TEST(short_compare), - - ADD_TEST(ushort_math), - ADD_TEST(ushort_logic), - ADD_TEST(ushort_shift), - ADD_TEST(ushort_compare), - - ADD_TEST(char_math), - ADD_TEST(char_logic), - ADD_TEST(char_shift), - ADD_TEST(char_compare), - - ADD_TEST(uchar_math), - ADD_TEST(uchar_logic), - ADD_TEST(uchar_shift), - ADD_TEST(uchar_compare), - - ADD_TEST(popcount), - - // Quick - ADD_TEST(quick_long_math), - ADD_TEST(quick_long_logic), - ADD_TEST(quick_long_shift), - ADD_TEST(quick_long_compare), - - ADD_TEST(quick_ulong_math), - ADD_TEST(quick_ulong_logic), - ADD_TEST(quick_ulong_shift), - ADD_TEST(quick_ulong_compare), - - ADD_TEST(quick_int_math), - ADD_TEST(quick_int_logic), - ADD_TEST(quick_int_shift), - ADD_TEST(quick_int_compare), - - ADD_TEST(quick_uint_math), - ADD_TEST(quick_uint_logic), - ADD_TEST(quick_uint_shift), - ADD_TEST(quick_uint_compare), - - ADD_TEST(quick_short_math), - ADD_TEST(quick_short_logic), - ADD_TEST(quick_short_shift), - ADD_TEST(quick_short_compare), - - ADD_TEST(quick_ushort_math), - ADD_TEST(quick_ushort_logic), - ADD_TEST(quick_ushort_shift), - ADD_TEST(quick_ushort_compare), - - ADD_TEST(quick_char_math), - ADD_TEST(quick_char_logic), - ADD_TEST(quick_char_shift), - ADD_TEST(quick_char_compare), - - ADD_TEST(quick_uchar_math), - ADD_TEST(quick_uchar_logic), - ADD_TEST(quick_uchar_shift), - ADD_TEST(quick_uchar_compare), - - ADD_TEST(vector_scalar), - - ADD_TEST(integer_dot_product), -}; - -const int test_num = ARRAY_SIZE(test_list); - void fill_test_values( cl_long *outBufferA, cl_long *outBufferB, size_t numElements, MTdata d ) { static const cl_long sUniqueValues[] = { 0x3333333333333333LL, 0x5555555555555555LL, 0x9999999999999999LL, 0xaaaaaaaaaaaaaaaaLL, 0xccccccccccccccccLL, @@ -218,6 +89,7 @@ void fill_test_values( cl_long *outBufferA, cl_long *outBufferB, size_t numEleme int main(int argc, const char *argv[]) { - return runTestHarness(argc, argv, test_num, test_list, false, 0); + return runTestHarness(argc, argv, test_registry::getInstance().num_tests(), + test_registry::getInstance().definitions(), false, 0); } diff --git a/test_conformance/integer_ops/procs.h b/test_conformance/integer_ops/procs.h deleted file mode 100644 index 0907938f..00000000 --- a/test_conformance/integer_ops/procs.h +++ /dev/null @@ -1,156 +0,0 @@ -// -// Copyright (c) 2017-2022 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/errorHelpers.h" -#include "harness/kernelHelpers.h" -#include "harness/typeWrappers.h" -#include "harness/testHarness.h" -#include "harness/mt19937.h" - - -// The number of errors to print out for each test -#define MAX_ERRORS_TO_PRINT 10 - -extern const size_t vector_aligns[]; - -extern int create_program_and_kernel(const char *source, const char *kernel_name, cl_program *program_ret, cl_kernel *kernel_ret); -extern void fill_test_values( cl_long *outBufferA, cl_long *outBufferB, size_t numElements, MTdata d ); - - -extern int test_popcount(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_clz(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_ctz(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_hadd(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_rhadd(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_mul_hi(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_rotate(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_clamp(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_mad_sat(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_mad_hi(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_min(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_max(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_upsample(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_integer_addAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_subtractAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_multiplyAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_divideAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_moduloAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_andAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_orAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_exclusiveOrAssign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_integer_abs(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_abs_diff(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_add_sat(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_sub_sat(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_integer_mul24(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_integer_mad24(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_extended_bit_ops_extract(cl_device_id device_id, - cl_context context, - cl_command_queue commands, - int num_elements); -extern int test_extended_bit_ops_insert(cl_device_id device_id, - cl_context context, - cl_command_queue commands, - int num_elements); -extern int test_extended_bit_ops_reverse(cl_device_id device_id, - cl_context context, - cl_command_queue commands, - int num_elements); - -extern int test_long_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_long_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_long_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_long_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ulong_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ulong_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ulong_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ulong_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_int_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_int_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_int_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_int_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uint_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uint_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uint_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uint_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_short_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_short_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_short_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_short_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ushort_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ushort_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ushort_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_ushort_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_char_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_char_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_char_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_char_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uchar_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uchar_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uchar_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_uchar_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - - -extern int test_quick_long_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_long_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_long_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_long_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ulong_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ulong_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ulong_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ulong_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_quick_int_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_int_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_int_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_int_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uint_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uint_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uint_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uint_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_quick_short_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_short_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_short_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_short_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ushort_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ushort_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ushort_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_ushort_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_quick_char_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_char_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_char_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_char_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uchar_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uchar_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uchar_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_quick_uchar_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_unary_ops_full(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_unary_ops_increment(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); -extern int test_unary_ops_decrement(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_vector_scalar(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); - -extern int test_integer_dot_product(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements); diff --git a/test_conformance/integer_ops/testBase.h b/test_conformance/integer_ops/testBase.h index 5b49bfd7..abc64b1e 100644 --- a/test_conformance/integer_ops/testBase.h +++ b/test_conformance/integer_ops/testBase.h @@ -17,13 +17,21 @@ #define _testBase_h #include "harness/compat.h" +#include "harness/errorHelpers.h" +#include "harness/kernelHelpers.h" +#include "harness/testHarness.h" +#include "harness/typeWrappers.h" #include #include #include #include -#include "procs.h" +// The number of errors to print out for each test +#define MAX_ERRORS_TO_PRINT 10 + +extern void fill_test_values(cl_long *outBufferA, cl_long *outBufferB, + size_t numElements, MTdata d); #endif // _testBase_h diff --git a/test_conformance/integer_ops/test_abs.cpp b/test_conformance/integer_ops/test_abs.cpp index 1e1bb305..128d7393 100644 --- a/test_conformance/integer_ops/test_abs.cpp +++ b/test_conformance/integer_ops/test_abs.cpp @@ -13,7 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" +#include "testBase.h" #include @@ -22,10 +22,6 @@ #include #include #include - -#include "procs.h" - - static int verify_abs_char( const void *p, const void *q, size_t n, const char *sizeName, size_t vecSize ) { const cl_char *inA = (const cl_char*) p; @@ -216,7 +212,7 @@ static const char * dest_stores[] = { " vstore3(tmp, tid, dst);\n" }; -int test_integer_abs(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(integer_abs) { cl_int *input_ptr, *output_ptr, *p; int err; @@ -226,15 +222,14 @@ int test_integer_abs(cl_device_id device, cl_context context, cl_command_queue q MTdata d; int fail_count = 0; - size_t length = sizeof(cl_int) * 4 * n_elems; + size_t length = sizeof(cl_int) * 4 * num_elements; input_ptr = (cl_int*)malloc(length); output_ptr = (cl_int*)malloc(length); p = input_ptr; d = init_genrand( gRandomSeed ); - for (i=0; i #include @@ -21,9 +21,6 @@ #include #include - -#include "procs.h" - template static typename std::make_unsigned::type abs_diff(Integer a, Integer b) { @@ -219,7 +216,7 @@ static void printSrc(const char *src[], int nSrcStrings) { } } -int test_integer_abs_diff(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(integer_abs_diff) { cl_int *input_ptr[2], *output_ptr, *p; int err; @@ -229,7 +226,7 @@ int test_integer_abs_diff(cl_device_id device, cl_context context, cl_command_qu MTdata d; int fail_count = 0; - size_t length = sizeof(cl_int) * 4 * n_elems; + size_t length = sizeof(cl_int) * 4 * num_elements; input_ptr[0] = (cl_int*)malloc(length); input_ptr[1] = (cl_int*)malloc(length); @@ -237,11 +234,9 @@ int test_integer_abs_diff(cl_device_id device, cl_context context, cl_command_qu d = init_genrand( gRandomSeed ); p = input_ptr[0]; - for (i=0; i<4 * n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 4 * num_elements; i++) p[i] = genrand_int32(d); p = input_ptr[1]; - for (i=0; i<4 * n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 4 * num_elements; i++) p[i] = genrand_int32(d); free_mtdata(d); d = NULL; for( type = 0; type < sizeof( test_str_names ) / sizeof( test_str_names[0] ); type++ ) @@ -405,5 +400,3 @@ int test_integer_abs_diff(cl_device_id device, cl_context context, cl_command_qu return err; } - - diff --git a/test_conformance/integer_ops/test_add_sat.cpp b/test_conformance/integer_ops/test_add_sat.cpp index a62b979c..c933dd5b 100644 --- a/test_conformance/integer_ops/test_add_sat.cpp +++ b/test_conformance/integer_ops/test_add_sat.cpp @@ -13,7 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" +#include "testBase.h" #include #include @@ -23,9 +23,6 @@ #include #include - -#include "procs.h" - static int verify_addsat_char( const cl_char *inA, const cl_char *inB, const cl_char *outptr, int n, const char *sizeName, int vecSize ) { int i; @@ -185,7 +182,7 @@ static const int vector_sizes[] = {1, 2, 3, 4, 8, 16}; static const char *vector_size_names[] = { "", "2", "3", "4", "8", "16" }; static const size_t kSizes[8] = { 1, 1, 2, 2, 4, 4, 8, 8 }; -int test_integer_add_sat(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(integer_add_sat) { cl_int *input_ptr[2], *output_ptr, *p; int err; @@ -195,7 +192,7 @@ int test_integer_add_sat(cl_device_id device, cl_context context, cl_command_que MTdata d; int fail_count = 0; - size_t length = sizeof(cl_int) * 4 * n_elems; + size_t length = sizeof(cl_int) * 4 * num_elements; input_ptr[0] = (cl_int*)malloc(length); input_ptr[1] = (cl_int*)malloc(length); @@ -203,11 +200,9 @@ int test_integer_add_sat(cl_device_id device, cl_context context, cl_command_que d = init_genrand( gRandomSeed ); p = input_ptr[0]; - for (i=0; i<4 * n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 4 * num_elements; i++) p[i] = genrand_int32(d); p = input_ptr[1]; - for (i=0; i<4 * n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 4 * num_elements; i++) p[i] = genrand_int32(d); free_mtdata(d); d = NULL; for( type = 0; type < sizeof( test_str_names ) / sizeof( test_str_names[0] ); type++ ) @@ -376,5 +371,3 @@ int test_integer_add_sat(cl_device_id device, cl_context context, cl_command_que return err; } - - diff --git a/test_conformance/integer_ops/test_extended_bit_ops_extract.cpp b/test_conformance/integer_ops/test_extended_bit_ops_extract.cpp index b9657fcb..a066e9f6 100644 --- a/test_conformance/integer_ops/test_extended_bit_ops_extract.cpp +++ b/test_conformance/integer_ops/test_extended_bit_ops_extract.cpp @@ -14,13 +14,13 @@ // limitations under the License. // +#include "testBase.h" + #include #include #include #include #include - -#include "procs.h" #include "harness/integer_ops_test_info.h" #include "harness/testHarness.h" @@ -261,8 +261,7 @@ static int test_type(cl_device_id device, cl_context context, | test_vectype(device, context, queue); } -int test_extended_bit_ops_extract(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(extended_bit_ops_extract) { if (is_extension_available(device, "cl_khr_extended_bit_ops")) { diff --git a/test_conformance/integer_ops/test_extended_bit_ops_insert.cpp b/test_conformance/integer_ops/test_extended_bit_ops_insert.cpp index e6d8522c..1fce0255 100644 --- a/test_conformance/integer_ops/test_extended_bit_ops_insert.cpp +++ b/test_conformance/integer_ops/test_extended_bit_ops_insert.cpp @@ -14,13 +14,13 @@ // limitations under the License. // +#include "testBase.h" + #include #include #include #include #include - -#include "procs.h" #include "harness/integer_ops_test_info.h" #include "harness/testHarness.h" @@ -188,8 +188,7 @@ static int test_type(cl_device_id device, cl_context context, | test_vectype(device, context, queue); } -int test_extended_bit_ops_insert(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(extended_bit_ops_insert) { if (is_extension_available(device, "cl_khr_extended_bit_ops")) { diff --git a/test_conformance/integer_ops/test_extended_bit_ops_reverse.cpp b/test_conformance/integer_ops/test_extended_bit_ops_reverse.cpp index 136f9d1d..6d2df657 100644 --- a/test_conformance/integer_ops/test_extended_bit_ops_reverse.cpp +++ b/test_conformance/integer_ops/test_extended_bit_ops_reverse.cpp @@ -14,12 +14,12 @@ // limitations under the License. // +#include "testBase.h" + #include #include #include #include - -#include "procs.h" #include "harness/integer_ops_test_info.h" #include "harness/testHarness.h" @@ -151,8 +151,7 @@ static int test_type(cl_device_id device, cl_context context, | test_vectype(device, context, queue); } -int test_extended_bit_ops_reverse(cl_device_id device, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(extended_bit_ops_reverse) { if (is_extension_available(device, "cl_khr_extended_bit_ops")) { diff --git a/test_conformance/integer_ops/test_int_basic_ops.cpp b/test_conformance/integer_ops/test_int_basic_ops.cpp index 519e5bee..b9a47d75 100644 --- a/test_conformance/integer_ops/test_int_basic_ops.cpp +++ b/test_conformance/integer_ops/test_int_basic_ops.cpp @@ -13,14 +13,13 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" +#include "testBase.h" #include #include #include #include -#include "procs.h" #include "harness/conversions.h" #include "harness/ThreadPool.h" @@ -887,316 +886,443 @@ int run_test(cl_device_id deviceID, cl_context context, cl_command_queue queue, // ----------------- // Long tests // ----------------- -int test_long_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(long_math) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_math(deviceID, context, queue, num_elements, kLong, LONG_MATH_SHIFT_SIZE); + return run_test_math(device, context, queue, num_elements, kLong, + LONG_MATH_SHIFT_SIZE); } -int test_long_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(long_logic) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_logic(deviceID, context, queue, num_elements, kLong, LONG_MATH_SHIFT_SIZE); + return run_test_logic(device, context, queue, num_elements, kLong, + LONG_MATH_SHIFT_SIZE); } -int test_long_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(long_shift) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_shift(deviceID, context, queue, num_elements, kLong, LONG_MATH_SHIFT_SIZE); + return run_test_shift(device, context, queue, num_elements, kLong, + LONG_MATH_SHIFT_SIZE); } -int test_long_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(long_compare) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_compare(deviceID, context, queue, num_elements, kLong, LONG_MATH_SHIFT_SIZE); + return run_test_compare(device, context, queue, num_elements, kLong, + LONG_MATH_SHIFT_SIZE); } -int test_quick_long_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_long_math) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_math(deviceID, context, queue, num_elements, kLong, QUICK_MATH_SHIFT_SIZE); + return run_test_math(device, context, queue, num_elements, kLong, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_long_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_long_logic) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_logic(deviceID, context, queue, num_elements, kLong, QUICK_MATH_SHIFT_SIZE); + return run_test_logic(device, context, queue, num_elements, kLong, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_long_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_long_shift) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_shift(deviceID, context, queue, num_elements, kLong, QUICK_MATH_SHIFT_SIZE); + return run_test_shift(device, context, queue, num_elements, kLong, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_long_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_long_compare) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_compare(deviceID, context, queue, num_elements, kLong, QUICK_MATH_SHIFT_SIZE); + return run_test_compare(device, context, queue, num_elements, kLong, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // ULong tests // ----------------- -int test_ulong_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(ulong_math) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_math(deviceID, context, queue, num_elements, kULong, LONG_MATH_SHIFT_SIZE); + return run_test_math(device, context, queue, num_elements, kULong, + LONG_MATH_SHIFT_SIZE); } -int test_ulong_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(ulong_logic) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_logic(deviceID, context, queue, num_elements, kULong, LONG_MATH_SHIFT_SIZE); + return run_test_logic(device, context, queue, num_elements, kULong, + LONG_MATH_SHIFT_SIZE); } -int test_ulong_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(ulong_shift) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_shift(deviceID, context, queue, num_elements, kULong, LONG_MATH_SHIFT_SIZE); + return run_test_shift(device, context, queue, num_elements, kULong, + LONG_MATH_SHIFT_SIZE); } -int test_ulong_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(ulong_compare) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_compare(deviceID, context, queue, num_elements, kULong, LONG_MATH_SHIFT_SIZE); + return run_test_compare(device, context, queue, num_elements, kULong, + LONG_MATH_SHIFT_SIZE); } -int test_quick_ulong_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_ulong_math) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_math(deviceID, context, queue, num_elements, kULong, QUICK_MATH_SHIFT_SIZE); + return run_test_math(device, context, queue, num_elements, kULong, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_ulong_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_ulong_logic) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_logic(deviceID, context, queue, num_elements, kULong, QUICK_MATH_SHIFT_SIZE); + return run_test_logic(device, context, queue, num_elements, kULong, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_ulong_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_ulong_shift) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_shift(deviceID, context, queue, num_elements, kULong, QUICK_MATH_SHIFT_SIZE); + return run_test_shift(device, context, queue, num_elements, kULong, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_ulong_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { +REGISTER_TEST(quick_ulong_compare) +{ if (!gHasLong) { log_info( "WARNING: 64 bit integers are not supported on this device. Skipping\n" ); return CL_SUCCESS; } - return run_test_compare(deviceID, context, queue, num_elements, kULong, QUICK_MATH_SHIFT_SIZE); + return run_test_compare(device, context, queue, num_elements, kULong, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // Int tests // ----------------- -int test_int_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(int_math) +{ + return run_test_math(device, context, queue, num_elements, kInt, + LONG_MATH_SHIFT_SIZE); } -int test_int_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(int_logic) +{ + return run_test_logic(device, context, queue, num_elements, kInt, + LONG_MATH_SHIFT_SIZE); } -int test_int_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(int_shift) +{ + return run_test_shift(device, context, queue, num_elements, kInt, + LONG_MATH_SHIFT_SIZE); } -int test_int_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(int_compare) +{ + return run_test_compare(device, context, queue, num_elements, kInt, + LONG_MATH_SHIFT_SIZE); } -int test_quick_int_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_int_math) +{ + return run_test_math(device, context, queue, num_elements, kInt, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_int_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_int_logic) +{ + return run_test_logic(device, context, queue, num_elements, kInt, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_int_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_int_shift) +{ + return run_test_shift(device, context, queue, num_elements, kInt, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_int_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_int_compare) +{ + return run_test_compare(device, context, queue, num_elements, kInt, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // UInt tests // ----------------- -int test_uint_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kUInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uint_math) +{ + return run_test_math(device, context, queue, num_elements, kUInt, + LONG_MATH_SHIFT_SIZE); } -int test_uint_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kUInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uint_logic) +{ + return run_test_logic(device, context, queue, num_elements, kUInt, + LONG_MATH_SHIFT_SIZE); } -int test_uint_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kUInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uint_shift) +{ + return run_test_shift(device, context, queue, num_elements, kUInt, + LONG_MATH_SHIFT_SIZE); } -int test_uint_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kUInt, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uint_compare) +{ + return run_test_compare(device, context, queue, num_elements, kUInt, + LONG_MATH_SHIFT_SIZE); } -int test_quick_uint_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kUInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uint_math) +{ + return run_test_math(device, context, queue, num_elements, kUInt, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_uint_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kUInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uint_logic) +{ + return run_test_logic(device, context, queue, num_elements, kUInt, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_uint_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kUInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uint_shift) +{ + return run_test_shift(device, context, queue, num_elements, kUInt, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_uint_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kUInt, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uint_compare) +{ + return run_test_compare(device, context, queue, num_elements, kUInt, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // Short tests // ----------------- -int test_short_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(short_math) +{ + return run_test_math(device, context, queue, num_elements, kShort, + LONG_MATH_SHIFT_SIZE); } -int test_short_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(short_logic) +{ + return run_test_logic(device, context, queue, num_elements, kShort, + LONG_MATH_SHIFT_SIZE); } -int test_short_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(short_shift) +{ + return run_test_shift(device, context, queue, num_elements, kShort, + LONG_MATH_SHIFT_SIZE); } -int test_short_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(short_compare) +{ + return run_test_compare(device, context, queue, num_elements, kShort, + LONG_MATH_SHIFT_SIZE); } -int test_quick_short_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_short_math) +{ + return run_test_math(device, context, queue, num_elements, kShort, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_short_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_short_logic) +{ + return run_test_logic(device, context, queue, num_elements, kShort, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_short_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_short_shift) +{ + return run_test_shift(device, context, queue, num_elements, kShort, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_short_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_short_compare) +{ + return run_test_compare(device, context, queue, num_elements, kShort, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // UShort tests // ----------------- -int test_ushort_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kUShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(ushort_math) +{ + return run_test_math(device, context, queue, num_elements, kUShort, + LONG_MATH_SHIFT_SIZE); } -int test_ushort_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kUShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(ushort_logic) +{ + return run_test_logic(device, context, queue, num_elements, kUShort, + LONG_MATH_SHIFT_SIZE); } -int test_ushort_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kUShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(ushort_shift) +{ + return run_test_shift(device, context, queue, num_elements, kUShort, + LONG_MATH_SHIFT_SIZE); } -int test_ushort_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kUShort, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(ushort_compare) +{ + return run_test_compare(device, context, queue, num_elements, kUShort, + LONG_MATH_SHIFT_SIZE); } -int test_quick_ushort_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kUShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_ushort_math) +{ + return run_test_math(device, context, queue, num_elements, kUShort, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_ushort_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kUShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_ushort_logic) +{ + return run_test_logic(device, context, queue, num_elements, kUShort, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_ushort_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kUShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_ushort_shift) +{ + return run_test_shift(device, context, queue, num_elements, kUShort, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_ushort_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kUShort, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_ushort_compare) +{ + return run_test_compare(device, context, queue, num_elements, kUShort, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // Char tests // ----------------- -int test_char_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(char_math) +{ + return run_test_math(device, context, queue, num_elements, kChar, + LONG_MATH_SHIFT_SIZE); } -int test_char_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(char_logic) +{ + return run_test_logic(device, context, queue, num_elements, kChar, + LONG_MATH_SHIFT_SIZE); } -int test_char_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(char_shift) +{ + return run_test_shift(device, context, queue, num_elements, kChar, + LONG_MATH_SHIFT_SIZE); } -int test_char_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(char_compare) +{ + return run_test_compare(device, context, queue, num_elements, kChar, + LONG_MATH_SHIFT_SIZE); } -int test_quick_char_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_char_math) +{ + return run_test_math(device, context, queue, num_elements, kChar, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_char_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_char_logic) +{ + return run_test_logic(device, context, queue, num_elements, kChar, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_char_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_char_shift) +{ + return run_test_shift(device, context, queue, num_elements, kChar, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_char_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_char_compare) +{ + return run_test_compare(device, context, queue, num_elements, kChar, + QUICK_MATH_SHIFT_SIZE); } // ----------------- // UChar tests // ----------------- -int test_uchar_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kUChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uchar_math) +{ + return run_test_math(device, context, queue, num_elements, kUChar, + LONG_MATH_SHIFT_SIZE); } -int test_uchar_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kUChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uchar_logic) +{ + return run_test_logic(device, context, queue, num_elements, kUChar, + LONG_MATH_SHIFT_SIZE); } -int test_uchar_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kUChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uchar_shift) +{ + return run_test_shift(device, context, queue, num_elements, kUChar, + LONG_MATH_SHIFT_SIZE); } -int test_uchar_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kUChar, LONG_MATH_SHIFT_SIZE); +REGISTER_TEST(uchar_compare) +{ + return run_test_compare(device, context, queue, num_elements, kUChar, + LONG_MATH_SHIFT_SIZE); } -int test_quick_uchar_math(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_math(deviceID, context, queue, num_elements, kUChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uchar_math) +{ + return run_test_math(device, context, queue, num_elements, kUChar, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_uchar_logic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_logic(deviceID, context, queue, num_elements, kUChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uchar_logic) +{ + return run_test_logic(device, context, queue, num_elements, kUChar, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_uchar_shift(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_shift(deviceID, context, queue, num_elements, kUChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uchar_shift) +{ + return run_test_shift(device, context, queue, num_elements, kUChar, + QUICK_MATH_SHIFT_SIZE); } -int test_quick_uchar_compare(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { - return run_test_compare(deviceID, context, queue, num_elements, kUChar, QUICK_MATH_SHIFT_SIZE); +REGISTER_TEST(quick_uchar_compare) +{ + return run_test_compare(device, context, queue, num_elements, kUChar, + QUICK_MATH_SHIFT_SIZE); } - // These are kept for debugging if you want to run all the tests together. int test_long(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) { @@ -1334,7 +1460,7 @@ int run_vector_scalar_tests( cl_device_id deviceID, cl_context context, cl_comma return errors; } -int test_vector_scalar(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(vector_scalar) { int errors = 0; int numTypes = sizeof( types ) / sizeof( types[ 0 ] ); @@ -1344,7 +1470,8 @@ int test_vector_scalar(cl_device_id deviceID, cl_context context, cl_command_que if ((types[ t ] == kLong || types[ t ] == kULong) && !gHasLong) continue; - errors += run_vector_scalar_tests( deviceID, context, queue, num_elements, types[ t ], 1 ); + errors += run_vector_scalar_tests(device, context, queue, num_elements, + types[t], 1); break; } diff --git a/test_conformance/integer_ops/test_integer_dot_product.cpp b/test_conformance/integer_ops/test_integer_dot_product.cpp index 602d59b6..22cf72f0 100644 --- a/test_conformance/integer_ops/test_integer_dot_product.cpp +++ b/test_conformance/integer_ops/test_integer_dot_product.cpp @@ -14,13 +14,14 @@ // limitations under the License. // +#include "testBase.h" + #include #include #include #include #include -#include "procs.h" #include "harness/integer_ops_test_info.h" #include "harness/testHarness.h" @@ -327,23 +328,22 @@ static int test_vectype_packed(cl_device_id deviceID, cl_context context, return result; } -int test_integer_dot_product(cl_device_id deviceID, cl_context context, - cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_dot_product) { - if (!is_extension_available(deviceID, "cl_khr_integer_dot_product")) + if (!is_extension_available(device, "cl_khr_integer_dot_product")) { log_info("cl_khr_integer_dot_product is not supported\n"); return TEST_SKIPPED_ITSELF; } - Version deviceVersion = get_device_cl_version(deviceID); + Version deviceVersion = get_device_cl_version(device); cl_version extensionVersion; if ((deviceVersion >= Version(3, 0)) - || is_extension_available(deviceID, "cl_khr_extended_versioning")) + || is_extension_available(device, "cl_khr_extended_versioning")) { extensionVersion = - get_extension_version(deviceID, "cl_khr_integer_dot_product"); + get_extension_version(device, "cl_khr_integer_dot_product"); } else { @@ -355,9 +355,9 @@ int test_integer_dot_product(cl_device_id deviceID, cl_context context, int result = TEST_PASS; cl_device_integer_dot_product_capabilities_khr dotCaps = 0; - error = clGetDeviceInfo(deviceID, - CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR, - sizeof(dotCaps), &dotCaps, NULL); + error = + clGetDeviceInfo(device, CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR, + sizeof(dotCaps), &dotCaps, NULL); test_error( error, "Unable to query CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR"); @@ -383,7 +383,7 @@ int test_integer_dot_product(cl_device_id deviceID, cl_context context, { size_t size_ret; error = clGetDeviceInfo( - deviceID, + device, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR, 0, nullptr, &size_ret); test_error( @@ -394,13 +394,13 @@ int test_integer_dot_product(cl_device_id deviceID, cl_context context, cl_device_integer_dot_product_acceleration_properties_khr accelerationProperties; error = clGetDeviceInfo( - deviceID, + device, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR, sizeof(accelerationProperties), &accelerationProperties, nullptr); test_error(error, "Unable to query 8-bit acceleration properties"); error = clGetDeviceInfo( - deviceID, + device, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR, 0, nullptr, &size_ret); test_error( @@ -410,7 +410,7 @@ int test_integer_dot_product(cl_device_id deviceID, cl_context context, "PACKED_KHR"); error = clGetDeviceInfo( - deviceID, + device, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR, sizeof(accelerationProperties), &accelerationProperties, nullptr); test_error(error, @@ -428,14 +428,14 @@ int test_integer_dot_product(cl_device_id deviceID, cl_context context, // Test built-in functions if (dotCaps & CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR) { - result |= test_vectype(deviceID, context, queue, + result |= test_vectype(device, context, queue, num_elements); } if (dotCaps & CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED_KHR) { result |= test_vectype_packed( - deviceID, context, queue, num_elements); + device, context, queue, num_elements); } return result; diff --git a/test_conformance/integer_ops/test_integers.cpp b/test_conformance/integer_ops/test_integers.cpp index 20f19a29..04cb2345 100644 --- a/test_conformance/integer_ops/test_integers.cpp +++ b/test_conformance/integer_ops/test_integers.cpp @@ -342,7 +342,7 @@ bool verify_integer_clz( void *source, void *destination, ExplicitType vecType ) return true; } -int test_integer_clz(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_clz) { return test_single_param_integer_fn( queue, context, "clz", verify_integer_clz ); } @@ -436,7 +436,7 @@ bool verify_integer_ctz( void *source, void *destination, ExplicitType vecType ) } -int test_integer_ctz(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_ctz) { return test_single_param_integer_fn( queue, context, "ctz", verify_integer_ctz ); } @@ -464,15 +464,17 @@ int test_integer_ctz(cl_device_id deviceID, cl_context context, cl_command_queue break; \ } -#define OP_TEST( op, opName ) \ - bool verify_integer_##opName##Assign( void *source, void *destination, ExplicitType vecType ) \ - { \ - OP_CASES( op ) \ - return true; \ - } \ - int test_integer_##opName##Assign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) \ - { \ - return test_single_param_integer_fn( queue, context, #op, verify_integer_##opName##Assign, true ); \ +#define OP_TEST(op, opName) \ + bool verify_integer_##opName##Assign(void *source, void *destination, \ + ExplicitType vecType) \ + { \ + OP_CASES(op) \ + return true; \ + } \ + REGISTER_TEST(integer_##opName##Assign) \ + { \ + return test_single_param_integer_fn( \ + queue, context, #op, verify_integer_##opName##Assign, true); \ } OP_TEST( +, add ) @@ -521,15 +523,17 @@ OP_TEST( &, and ) break; \ } -#define OP_TEST_GUARD( op, opName ) \ - bool verify_integer_##opName##Assign( void *source, void *destination, ExplicitType vecType ) \ - { \ - OP_CASES_GUARD( op ) \ - return true; \ - } \ - int test_integer_##opName##Assign(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) \ - { \ - return test_single_param_integer_fn( queue, context, #op, verify_integer_##opName##Assign, true ); \ +#define OP_TEST_GUARD(op, opName) \ + bool verify_integer_##opName##Assign(void *source, void *destination, \ + ExplicitType vecType) \ + { \ + OP_CASES_GUARD(op) \ + return true; \ + } \ + REGISTER_TEST(integer_##opName##Assign) \ + { \ + return test_single_param_integer_fn( \ + queue, context, #op, verify_integer_##opName##Assign, true); \ } OP_TEST_GUARD( /, divide ) @@ -898,7 +902,7 @@ bool verify_integer_hadd( void *sourceA, void *sourceB, void *destination, Expli return true; } -int test_integer_hadd(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_hadd) { return test_two_param_integer_fn( queue, context, "hadd", verify_integer_hadd ); } @@ -961,7 +965,7 @@ bool verify_integer_rhadd( void *sourceA, void *sourceB, void *destination, Expl return true; } -int test_integer_rhadd(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_rhadd) { return test_two_param_integer_fn( queue, context, "rhadd", verify_integer_rhadd ); } @@ -994,7 +998,7 @@ bool verify_integer_min( void *sourceA, void *sourceB, void *destination, Explic return true; } -int test_integer_min(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_min) { return test_two_param_integer_fn( queue, context, "min", verify_integer_min); } @@ -1027,7 +1031,7 @@ bool verify_integer_max( void *sourceA, void *sourceB, void *destination, Explic return true; } -int test_integer_max(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_max) { return test_two_param_integer_fn( queue, context, "max", verify_integer_max ); } @@ -1195,7 +1199,7 @@ bool verify_integer_mul_hi( void *sourceA, void *sourceB, void *destination, Exp return true; } -int test_integer_mul_hi(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_mul_hi) { return test_two_param_integer_fn( queue, context, "mul_hi", verify_integer_mul_hi ); } @@ -1256,7 +1260,7 @@ bool verify_integer_rotate( void *sourceA, void *sourceB, void *destination, Exp return true; } -int test_integer_rotate(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_rotate) { return test_two_param_integer_fn( queue, context, "rotate", verify_integer_rotate ); } @@ -1615,7 +1619,7 @@ bool verify_integer_clamp( void *sourceA, void *sourceB, void *sourceC, void *de return true; } -int test_integer_clamp(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_clamp) { return test_three_param_integer_fn( queue, context, "clamp", verify_integer_clamp ); } @@ -1785,7 +1789,7 @@ bool verify_integer_mad_sat( void *sourceA, void *sourceB, void *sourceC, void * return true; } -int test_integer_mad_sat(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_mad_sat) { return test_three_param_integer_fn( queue, context, "mad_sat", verify_integer_mad_sat ); } @@ -1907,7 +1911,7 @@ bool verify_integer_mad_hi( void *sourceA, void *sourceB, void *sourceC, void *d return true; } -int test_integer_mad_hi( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_mad_hi) { return test_three_param_integer_fn( queue, context, "mad_hi", verify_integer_mad_hi ); } diff --git a/test_conformance/integer_ops/test_intmad24.cpp b/test_conformance/integer_ops/test_intmad24.cpp index d0fb3af9..0ef8e5f2 100644 --- a/test_conformance/integer_ops/test_intmad24.cpp +++ b/test_conformance/integer_ops/test_intmad24.cpp @@ -13,15 +13,12 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" +#include "testBase.h" #include #include #include #include - -#include "procs.h" - #define NUM_PROGRAMS 6 static const int vector_sizes[] = {1, 2, 3, 4, 8, 16}; @@ -187,7 +184,7 @@ static inline int random_int32( MTdata d ) } -int test_integer_mad24(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(integer_mad24) { cl_mem streams[4]; cl_int *input_ptr[3], *output_ptr, *p; @@ -196,13 +193,13 @@ int test_integer_mad24(cl_device_id device, cl_context context, cl_command_queue cl_kernel kernel[2*NUM_PROGRAMS]; size_t threads[1]; - int num_elements; + int n_elems; int err; int i; MTdata d; - size_t length = sizeof(cl_int) * 16 * n_elems; - num_elements = n_elems * 16; + size_t length = sizeof(cl_int) * 16 * num_elements; + n_elems = num_elements * 16; input_ptr[0] = (cl_int*)malloc(length); input_ptr[1] = (cl_int*)malloc(length); @@ -220,14 +217,11 @@ int test_integer_mad24(cl_device_id device, cl_context context, cl_command_queue d = init_genrand( gRandomSeed ); p = input_ptr[0]; - for (i=0; i #include #include #include - -#include "procs.h" - #define NUM_PROGRAMS 6 static const int vector_sizes[] = {1, 2, 3, 4, 8, 16}; @@ -173,7 +170,7 @@ static inline int random_int24( MTdata d ) static const char *test_str_names[] = { "int", "int2", "int3", "int4", "int8", "int16", "uint", "uint2", "uint3", "uint4", "uint8", "uint16" }; -int test_integer_mul24(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(integer_mul24) { cl_mem streams[3]; cl_int *input_ptr[2], *output_ptr, *p; @@ -182,13 +179,13 @@ int test_integer_mul24(cl_device_id device, cl_context context, cl_command_queue cl_kernel kernel[NUM_PROGRAMS*2]; size_t threads[1]; - int num_elements; + int n_elems; int err; int i; MTdata d; - size_t length = sizeof(cl_int) * 16 * n_elems; - num_elements = n_elems * 16; + size_t length = sizeof(cl_int) * 16 * num_elements; + n_elems = num_elements * 16; input_ptr[0] = (cl_int*)malloc(length); input_ptr[1] = (cl_int*)malloc(length); @@ -215,11 +212,9 @@ int test_integer_mul24(cl_device_id device, cl_context context, cl_command_queue d = init_genrand( gRandomSeed ); p = input_ptr[0]; - for (i=0; i #include @@ -21,9 +21,6 @@ #include #include - -#include "procs.h" - #define str(s) #s #define __popcnt(x, __T, __n, __r) \ @@ -92,7 +89,7 @@ static void printSrc(const char *src[], int nSrcStrings) { } } -int test_popcount(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(popcount) { cl_int *input_ptr[1], *output_ptr, *p; int err; @@ -102,15 +99,14 @@ int test_popcount(cl_device_id device, cl_context context, cl_command_queue queu MTdata d; int fail_count = 0; - size_t length = sizeof(cl_int) * 8 * n_elems; + size_t length = sizeof(cl_int) * 8 * num_elements; input_ptr[0] = (cl_int*)malloc(length); output_ptr = (cl_int*)malloc(length); d = init_genrand( gRandomSeed ); p = input_ptr[0]; - for (i=0; i<8 * n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 8 * num_elements; i++) p[i] = genrand_int32(d); free_mtdata(d); d = NULL; for( type = 0; type < sizeof( test_str_names ) / sizeof( test_str_names[0] ); type++ ) @@ -248,5 +244,3 @@ int test_popcount(cl_device_id device, cl_context context, cl_command_queue queu return err; } - - diff --git a/test_conformance/integer_ops/test_sub_sat.cpp b/test_conformance/integer_ops/test_sub_sat.cpp index d5348728..b0276fa6 100644 --- a/test_conformance/integer_ops/test_sub_sat.cpp +++ b/test_conformance/integer_ops/test_sub_sat.cpp @@ -13,7 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" +#include "testBase.h" #include #include @@ -23,9 +23,6 @@ #include #include - -#include "procs.h" - static int verify_subsat_char( const cl_char *inA, const cl_char *inB, const cl_char *outptr, int n, const char *sizeName, int vecSize ) { int i; @@ -184,7 +181,7 @@ static const char *vector_size_names[] = { "", "2", "3", "4", "8", "16" }; static const size_t kSizes[8] = { 1, 1, 2, 2, 4, 4, 8, 8 }; -int test_integer_sub_sat(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems) +REGISTER_TEST(integer_sub_sat) { int *input_ptr[2], *output_ptr, *p; int err; @@ -194,7 +191,7 @@ int test_integer_sub_sat(cl_device_id device, cl_context context, cl_command_que MTdata d; int fail_count = 0; - size_t length = sizeof(int) * 4 * n_elems; + size_t length = sizeof(int) * 4 * num_elements; input_ptr[0] = (int*)malloc(length); input_ptr[1] = (int*)malloc(length); @@ -202,11 +199,9 @@ int test_integer_sub_sat(cl_device_id device, cl_context context, cl_command_que d = init_genrand( gRandomSeed ); p = input_ptr[0]; - for (i=0; i<4 * (cl_uint) n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 4 * (cl_uint)num_elements; i++) p[i] = genrand_int32(d); p = input_ptr[1]; - for (i=0; i<4 * (cl_uint) n_elems; i++) - p[i] = genrand_int32(d); + for (i = 0; i < 4 * (cl_uint)num_elements; i++) p[i] = genrand_int32(d); free_mtdata(d); d = NULL; for( type = 0; type < sizeof( test_str_names ) / sizeof( test_str_names[0] ); type++ ) @@ -374,5 +369,3 @@ int test_integer_sub_sat(cl_device_id device, cl_context context, cl_command_que return err; } - - diff --git a/test_conformance/integer_ops/test_unary_ops.cpp b/test_conformance/integer_ops/test_unary_ops.cpp index 1f7fe855..04d81ada 100644 --- a/test_conformance/integer_ops/test_unary_ops.cpp +++ b/test_conformance/integer_ops/test_unary_ops.cpp @@ -198,17 +198,17 @@ int test_unary_op_set( cl_command_queue queue, cl_context context, OpKonstants w return retVal; } -int test_unary_ops_full(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(unary_ops_full) { return test_unary_op_set( queue, context, kBoth ); } -int test_unary_ops_increment(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(unary_ops_increment) { return test_unary_op_set( queue, context, kIncrement ); } -int test_unary_ops_decrement(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(unary_ops_decrement) { return test_unary_op_set( queue, context, kDecrement ); } diff --git a/test_conformance/integer_ops/test_upsample.cpp b/test_conformance/integer_ops/test_upsample.cpp index 33ecb586..f7fb2bd1 100644 --- a/test_conformance/integer_ops/test_upsample.cpp +++ b/test_conformance/integer_ops/test_upsample.cpp @@ -220,7 +220,7 @@ void * create_upsample_data( ExplicitType type, void *sourceA, void *sourceB, si return outData; } -int test_integer_upsample(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) +REGISTER_TEST(integer_upsample) { ExplicitType typesToTest[] = { kChar, kUChar, kShort, kUShort, kInt, kUInt, kNumExplicitTypes }; ExplicitType baseTypes[] = { kUChar, kUChar, kUShort, kUShort, kUInt, kUInt, kNumExplicitTypes }; @@ -264,5 +264,3 @@ int test_integer_upsample(cl_device_id deviceID, cl_context context, cl_command_ } return err; } - - diff --git a/test_conformance/integer_ops/verification_and_generation_functions.cpp b/test_conformance/integer_ops/verification_and_generation_functions.cpp index 1b745999..9a7abf78 100644 --- a/test_conformance/integer_ops/verification_and_generation_functions.cpp +++ b/test_conformance/integer_ops/verification_and_generation_functions.cpp @@ -13,7 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#include "harness/compat.h" +#include "testBase.h" #include #include @@ -22,7 +22,6 @@ #include -#include "procs.h" #include "harness/conversions.h" extern MTdata d; @@ -81,11 +80,6 @@ const char *test_names[] = { "!", // 22 }; -const size_t vector_aligns[] = {0, 1, 2, 4, 4, - 8, 8, 8, 8, - 16, 16, 16, 16, - 16, 16, 16, 16}; - // ======================================= // long // ======================================= diff --git a/test_conformance/math_brute_force/binary_double.cpp b/test_conformance/math_brute_force/binary_double.cpp index 5510c7a2..6262c7db 100644 --- a/test_conformance/math_brute_force/binary_double.cpp +++ b/test_conformance/math_brute_force/binary_double.cpp @@ -605,7 +605,7 @@ int TestFunc_Double_Double_Double(const Func *f, MTdata d, bool relaxedMode) } test_info.f = f; - test_info.ulps = f->double_ulps; + test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode); test_info.ftz = f->ftz || gForceFTZ; test_info.relaxedMode = relaxedMode; diff --git a/test_conformance/math_brute_force/binary_i_double.cpp b/test_conformance/math_brute_force/binary_i_double.cpp index 5f563c73..4428b422 100644 --- a/test_conformance/math_brute_force/binary_i_double.cpp +++ b/test_conformance/math_brute_force/binary_i_double.cpp @@ -522,7 +522,7 @@ int TestFunc_Double_Double_Int(const Func *f, MTdata d, bool relaxedMode) } test_info.f = f; - test_info.ulps = f->double_ulps; + test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode); test_info.ftz = f->ftz || gForceFTZ; test_info.relaxedMode = relaxedMode; diff --git a/test_conformance/math_brute_force/binary_operator_double.cpp b/test_conformance/math_brute_force/binary_operator_double.cpp index 35d93f84..e02c8d11 100644 --- a/test_conformance/math_brute_force/binary_operator_double.cpp +++ b/test_conformance/math_brute_force/binary_operator_double.cpp @@ -571,7 +571,7 @@ int TestFunc_Double_Double_Double_Operator(const Func *f, MTdata d, } test_info.f = f; - test_info.ulps = f->double_ulps; + test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode); test_info.ftz = f->ftz || gForceFTZ; test_info.tinfo.resize(test_info.threadCount); diff --git a/test_conformance/math_brute_force/binary_two_results_i_double.cpp b/test_conformance/math_brute_force/binary_two_results_i_double.cpp index eca33f2f..6b29102d 100644 --- a/test_conformance/math_brute_force/binary_two_results_i_double.cpp +++ b/test_conformance/math_brute_force/binary_two_results_i_double.cpp @@ -91,6 +91,7 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) cl_uint threadCount = GetThreadCount(); Force64BitFPUPrecision(); + float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode); int testingRemquo = !strcmp(f->name, "remquo"); @@ -256,6 +257,7 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) // Verify data uint64_t *t = (uint64_t *)gOut_Ref; int32_t *t2 = (int32_t *)gOut_Ref2; + for (size_t j = 0; j < BUFFER_SIZE / sizeof(double); j++) { for (auto k = gMinVectorSizeIndex; k < gMaxVectorSizeIndex; k++) @@ -294,11 +296,11 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) || isnan(((double *)gIn)[j]); if (iptrUndefined) iErr = 0; - int fail = !(fabsf(err) <= f->double_ulps && iErr == 0); + int fail = !(fabsf(err) <= double_ulps && iErr == 0); if ((ftz || relaxedMode) && fail) { // retry per section 6.5.3.2 - if (IsDoubleResultSubnormal(correct, f->double_ulps)) + if (IsDoubleResultSubnormal(correct, double_ulps)) { fail = fail && !(test == 0.0f && iErr == 0); if (!fail) err = 0.0f; @@ -319,8 +321,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) int64_t iErr3 = (long long)q2[j] - (long long)correct3i; int64_t iErr4 = (long long)q2[j] - (long long)correct4i; fail = fail - && ((!(fabsf(err2) <= f->double_ulps && iErr3 == 0)) - && (!(fabsf(err3) <= f->double_ulps + && ((!(fabsf(err2) <= double_ulps && iErr3 == 0)) + && (!(fabsf(err3) <= double_ulps && iErr4 == 0))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; @@ -328,9 +330,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) if (llabs(iErr4) < llabs(iErr)) iErr = iErr4; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correct2, f->double_ulps) - || IsDoubleResultSubnormal(correct3, - f->double_ulps)) + if (IsDoubleResultSubnormal(correct2, double_ulps) + || IsDoubleResultSubnormal(correct3, double_ulps)) { fail = fail && !(test == 0.0f @@ -361,13 +362,13 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) int64_t iErr8 = (long long)q2[j] - (long long)correct8i; fail = fail - && ((!(fabsf(err2) <= f->double_ulps + && ((!(fabsf(err2) <= double_ulps && iErr3 == 0)) - && (!(fabsf(err3) <= f->double_ulps + && (!(fabsf(err3) <= double_ulps && iErr4 == 0)) - && (!(fabsf(err4) <= f->double_ulps + && (!(fabsf(err4) <= double_ulps && iErr7 == 0)) - && (!(fabsf(err5) <= f->double_ulps + && (!(fabsf(err5) <= double_ulps && iErr8 == 0))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; @@ -379,14 +380,13 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) if (llabs(iErr8) < llabs(iErr)) iErr = iErr8; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correct3, - f->double_ulps) + if (IsDoubleResultSubnormal(correct3, double_ulps) || IsDoubleResultSubnormal(correct4, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct7, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct8, - f->double_ulps)) + double_ulps)) { fail = fail && !(test == 0.0f @@ -410,8 +410,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) int64_t iErr3 = (long long)q2[j] - (long long)correct3i; int64_t iErr4 = (long long)q2[j] - (long long)correct4i; fail = fail - && ((!(fabsf(err2) <= f->double_ulps && iErr3 == 0)) - && (!(fabsf(err3) <= f->double_ulps + && ((!(fabsf(err2) <= double_ulps && iErr3 == 0)) + && (!(fabsf(err3) <= double_ulps && iErr4 == 0))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; @@ -419,9 +419,8 @@ int TestFunc_DoubleI_Double_Double(const Func *f, MTdata d, bool relaxedMode) if (llabs(iErr4) < llabs(iErr)) iErr = iErr4; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correct2, f->double_ulps) - || IsDoubleResultSubnormal(correct3, - f->double_ulps)) + if (IsDoubleResultSubnormal(correct2, double_ulps) + || IsDoubleResultSubnormal(correct3, double_ulps)) { fail = fail && !(test == 0.0f diff --git a/test_conformance/math_brute_force/ternary_double.cpp b/test_conformance/math_brute_force/ternary_double.cpp index aadebc25..88d15c22 100644 --- a/test_conformance/math_brute_force/ternary_double.cpp +++ b/test_conformance/math_brute_force/ternary_double.cpp @@ -127,6 +127,8 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, double maxErrorVal3 = 0.0f; uint64_t step = getTestStep(sizeof(double), BUFFER_SIZE); + float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode); + logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); Force64BitFPUPrecision(); @@ -295,7 +297,7 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, double test = ((double *)q)[j]; long double correct = f->dfunc.f_fff(s[j], s2[j], s3[j]); float err = Bruteforce_Ulp_Error_Double(test, correct); - int fail = !(fabsf(err) <= f->double_ulps); + int fail = !(fabsf(err) <= double_ulps); if (fail && (ftz || relaxedMode)) { @@ -318,16 +320,15 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err3 = Bruteforce_Ulp_Error_Double(test, correct3); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correct2, - f->double_ulps) + if (IsDoubleResultSubnormal(correct2, double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps)) + double_ulps)) { // look at me now, fail = fail && (test != 0.0f); if (!fail) err = 0.0f; @@ -351,10 +352,10 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err5 = Bruteforce_Ulp_Error_Double(test, correct5); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) <= f->double_ulps)) - && (!(fabsf(err4) <= f->double_ulps)) - && (!(fabsf(err5) <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps)) + && (!(fabsf(err4) <= double_ulps)) + && (!(fabsf(err5) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err4) < fabsf(err)) err = err4; @@ -362,13 +363,13 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, // retry per section 6.5.3.4 if (IsDoubleResultSubnormal(correct2, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct4, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct5, - f->double_ulps)) + double_ulps)) { fail = fail && (test != 0.0f); if (!fail) err = 0.0f; @@ -405,21 +406,14 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err9 = Bruteforce_Ulp_Error_Double( test, correct9); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) - <= f->double_ulps)) - && (!(fabsf(err4) - <= f->double_ulps)) - && (!(fabsf(err5) - <= f->double_ulps)) - && (!(fabsf(err5) - <= f->double_ulps)) - && (!(fabsf(err6) - <= f->double_ulps)) - && (!(fabsf(err7) - <= f->double_ulps)) - && (!(fabsf(err8) - <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps)) + && (!(fabsf(err4) <= double_ulps)) + && (!(fabsf(err5) <= double_ulps)) + && (!(fabsf(err5) <= double_ulps)) + && (!(fabsf(err6) <= double_ulps)) + && (!(fabsf(err7) <= double_ulps)) + && (!(fabsf(err8) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err4) < fabsf(err)) err = err4; @@ -431,21 +425,21 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, // retry per section 6.5.3.4 if (IsDoubleResultSubnormal(correct2, - f->double_ulps) - || IsDoubleResultSubnormal( - correct3, f->double_ulps) - || IsDoubleResultSubnormal( - correct4, f->double_ulps) - || IsDoubleResultSubnormal( - correct5, f->double_ulps) - || IsDoubleResultSubnormal( - correct6, f->double_ulps) - || IsDoubleResultSubnormal( - correct7, f->double_ulps) - || IsDoubleResultSubnormal( - correct8, f->double_ulps) - || IsDoubleResultSubnormal( - correct9, f->double_ulps)) + double_ulps) + || IsDoubleResultSubnormal(correct3, + double_ulps) + || IsDoubleResultSubnormal(correct4, + double_ulps) + || IsDoubleResultSubnormal(correct5, + double_ulps) + || IsDoubleResultSubnormal(correct6, + double_ulps) + || IsDoubleResultSubnormal(correct7, + double_ulps) + || IsDoubleResultSubnormal(correct8, + double_ulps) + || IsDoubleResultSubnormal(correct9, + double_ulps)) { fail = fail && (test != 0.0f); if (!fail) err = 0.0f; @@ -469,10 +463,10 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err5 = Bruteforce_Ulp_Error_Double(test, correct5); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) <= f->double_ulps)) - && (!(fabsf(err4) <= f->double_ulps)) - && (!(fabsf(err5) <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps)) + && (!(fabsf(err4) <= double_ulps)) + && (!(fabsf(err5) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err4) < fabsf(err)) err = err4; @@ -480,13 +474,13 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, // retry per section 6.5.3.4 if (IsDoubleResultSubnormal(correct2, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct4, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct5, - f->double_ulps)) + double_ulps)) { fail = fail && (test != 0.0f); if (!fail) err = 0.0f; @@ -504,16 +498,15 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err3 = Bruteforce_Ulp_Error_Double(test, correct3); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correct2, - f->double_ulps) + if (IsDoubleResultSubnormal(correct2, double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps)) + double_ulps)) { fail = fail && (test != 0.0f); if (!fail) err = 0.0f; @@ -537,10 +530,10 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err5 = Bruteforce_Ulp_Error_Double(test, correct5); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) <= f->double_ulps)) - && (!(fabsf(err4) <= f->double_ulps)) - && (!(fabsf(err5) <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps)) + && (!(fabsf(err4) <= double_ulps)) + && (!(fabsf(err5) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; if (fabsf(err4) < fabsf(err)) err = err4; @@ -548,13 +541,13 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, // retry per section 6.5.3.4 if (IsDoubleResultSubnormal(correct2, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct4, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct5, - f->double_ulps)) + double_ulps)) { fail = fail && (test != 0.0f); if (!fail) err = 0.0f; @@ -572,16 +565,15 @@ int TestFunc_Double_Double_Double_Double(const Func *f, MTdata d, float err3 = Bruteforce_Ulp_Error_Double(test, correct3); fail = fail - && ((!(fabsf(err2) <= f->double_ulps)) - && (!(fabsf(err3) <= f->double_ulps))); + && ((!(fabsf(err2) <= double_ulps)) + && (!(fabsf(err3) <= double_ulps))); if (fabsf(err2) < fabsf(err)) err = err2; if (fabsf(err3) < fabsf(err)) err = err3; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correct2, - f->double_ulps) + if (IsDoubleResultSubnormal(correct2, double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps)) + double_ulps)) { fail = fail && (test != 0.0f); if (!fail) err = 0.0f; diff --git a/test_conformance/math_brute_force/unary_double.cpp b/test_conformance/math_brute_force/unary_double.cpp index 5c537332..74689a68 100644 --- a/test_conformance/math_brute_force/unary_double.cpp +++ b/test_conformance/math_brute_force/unary_double.cpp @@ -354,7 +354,7 @@ int TestFunc_Double_Double(const Func *f, MTdata d, bool relaxedMode) } test_info.f = f; - test_info.ulps = f->double_ulps; + test_info.ulps = getAllowedUlpError(f, kdouble, relaxedMode); test_info.ftz = f->ftz || gForceFTZ; test_info.relaxedMode = relaxedMode; diff --git a/test_conformance/math_brute_force/unary_two_results_double.cpp b/test_conformance/math_brute_force/unary_two_results_double.cpp index a109cd6e..a7e7e09b 100644 --- a/test_conformance/math_brute_force/unary_two_results_double.cpp +++ b/test_conformance/math_brute_force/unary_two_results_double.cpp @@ -56,6 +56,7 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode) logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); Force64BitFPUPrecision(); + float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode); // Init the kernels BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode, @@ -214,15 +215,14 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode) long double correct = f->dfunc.f_fpf(s[j], &correct2); float err = Bruteforce_Ulp_Error_Double(test, correct); float err2 = Bruteforce_Ulp_Error_Double(test2, correct2); - int fail = !(fabsf(err) <= f->double_ulps - && fabsf(err2) <= f->double_ulps); + int fail = !(fabsf(err) <= double_ulps + && fabsf(err2) <= double_ulps); if (ftz || relaxedMode) { // retry per section 6.5.3.2 - if (IsDoubleResultSubnormal(correct, f->double_ulps)) + if (IsDoubleResultSubnormal(correct, double_ulps)) { - if (IsDoubleResultSubnormal(correct2, - f->double_ulps)) + if (IsDoubleResultSubnormal(correct2, double_ulps)) { fail = fail && !(test == 0.0f && test2 == 0.0f); if (!fail) @@ -235,16 +235,15 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode) { fail = fail && !(test == 0.0f - && fabsf(err2) <= f->double_ulps); + && fabsf(err2) <= double_ulps); if (!fail) err = 0.0f; } } - else if (IsDoubleResultSubnormal(correct2, - f->double_ulps)) + else if (IsDoubleResultSubnormal(correct2, double_ulps)) { fail = fail && !(test2 == 0.0f - && fabsf(err) <= f->double_ulps); + && fabsf(err) <= double_ulps); if (!fail) err2 = 0.0f; } @@ -265,26 +264,24 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode) float err2n = Bruteforce_Ulp_Error_Double(test, correct2n); fail = fail - && ((!(fabsf(errp) <= f->double_ulps)) - && (!(fabsf(err2p) <= f->double_ulps)) - && ((!(fabsf(errn) <= f->double_ulps)) - && (!(fabsf(err2n) - <= f->double_ulps)))); + && ((!(fabsf(errp) <= double_ulps)) + && (!(fabsf(err2p) <= double_ulps)) + && ((!(fabsf(errn) <= double_ulps)) + && (!(fabsf(err2n) <= double_ulps)))); if (fabsf(errp) < fabsf(err)) err = errp; if (fabsf(errn) < fabsf(err)) err = errn; if (fabsf(err2p) < fabsf(err2)) err2 = err2p; if (fabsf(err2n) < fabsf(err2)) err2 = err2n; // retry per section 6.5.3.4 - if (IsDoubleResultSubnormal(correctp, - f->double_ulps) + if (IsDoubleResultSubnormal(correctp, double_ulps) || IsDoubleResultSubnormal(correctn, - f->double_ulps)) + double_ulps)) { if (IsDoubleResultSubnormal(correct2p, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct2n, - f->double_ulps)) + double_ulps)) { fail = fail && !(test == 0.0f && test2 == 0.0f); @@ -294,18 +291,18 @@ int TestFunc_Double2_Double(const Func *f, MTdata d, bool relaxedMode) { fail = fail && !(test == 0.0f - && fabsf(err2) <= f->double_ulps); + && fabsf(err2) <= double_ulps); if (!fail) err = 0.0f; } } else if (IsDoubleResultSubnormal(correct2p, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct2n, - f->double_ulps)) + double_ulps)) { fail = fail && !(test2 == 0.0f - && (fabsf(err) <= f->double_ulps)); + && (fabsf(err) <= double_ulps)); if (!fail) err2 = 0.0f; } } diff --git a/test_conformance/math_brute_force/unary_two_results_i_double.cpp b/test_conformance/math_brute_force/unary_two_results_i_double.cpp index dd60f43e..9197ded8 100644 --- a/test_conformance/math_brute_force/unary_two_results_i_double.cpp +++ b/test_conformance/math_brute_force/unary_two_results_i_double.cpp @@ -56,7 +56,9 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode) int ftz = f->ftz || gForceFTZ; double maxErrorVal = 0.0f; double maxErrorVal2 = 0.0f; - cl_ulong maxiError = f->double_ulps == INFINITY ? CL_ULONG_MAX : 0; + cl_ulong maxiError = getAllowedUlpError(f, kdouble, relaxedMode) == INFINITY + ? CL_ULONG_MAX + : 0; uint64_t step = getTestStep(sizeof(cl_double), BUFFER_SIZE); int scale = (int)((1ULL << 32) / (16 * BUFFER_SIZE / sizeof(cl_double)) + 1); @@ -64,6 +66,7 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode) logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); Force64BitFPUPrecision(); + float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode); // Init the kernels BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode, @@ -217,12 +220,12 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode) long double correct = f->dfunc.f_fpI(s[j], &correct2); float err = Bruteforce_Ulp_Error_Double(test, correct); cl_long iErr = (long long)q2[j] - (long long)correct2; - int fail = !(fabsf(err) <= f->double_ulps + int fail = !(fabsf(err) <= double_ulps && abs_cl_long(iErr) <= maxiError); if (ftz || relaxedMode) { // retry per section 6.5.3.2 - if (IsDoubleResultSubnormal(correct, f->double_ulps)) + if (IsDoubleResultSubnormal(correct, double_ulps)) { fail = fail && !(test == 0.0f && iErr == 0); if (!fail) err = 0.0f; @@ -246,7 +249,7 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode) (long long)q2[j] - (long long)correct6; // Did +0 work? - if (fabsf(err2) <= f->double_ulps + if (fabsf(err2) <= double_ulps && abs_cl_long(iErr2) <= maxiError) { err = err2; @@ -254,7 +257,7 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode) fail = 0; } // Did -0 work? - else if (fabsf(err3) <= f->double_ulps + else if (fabsf(err3) <= double_ulps && abs_cl_long(iErr3) <= maxiError) { err = err3; @@ -265,9 +268,9 @@ int TestFunc_DoubleI_Double(const Func *f, MTdata d, bool relaxedMode) // retry per section 6.5.3.4 if (fail && (IsDoubleResultSubnormal(correct2, - f->double_ulps) + double_ulps) || IsDoubleResultSubnormal(correct3, - f->double_ulps))) + double_ulps))) { fail = fail && !(test == 0.0f diff --git a/test_conformance/math_brute_force/unary_u_double.cpp b/test_conformance/math_brute_force/unary_u_double.cpp index 514b7c60..009611c1 100644 --- a/test_conformance/math_brute_force/unary_u_double.cpp +++ b/test_conformance/math_brute_force/unary_u_double.cpp @@ -56,6 +56,7 @@ int TestFunc_Double_ULong(const Func *f, MTdata d, bool relaxedMode) logFunctionInfo(f->name, sizeof(cl_double), relaxedMode); Force64BitFPUPrecision(); + float double_ulps = getAllowedUlpError(f, kdouble, relaxedMode); // Init the kernels BuildKernelInfo build_info{ 1, kernels, programs, f->nameInCode, @@ -167,15 +168,14 @@ int TestFunc_Double_ULong(const Func *f, MTdata d, bool relaxedMode) double test = ((double *)q)[j]; long double correct = f->dfunc.f_u(s[j]); float err = Bruteforce_Ulp_Error_Double(test, correct); - int fail = !(fabsf(err) <= f->double_ulps); + int fail = !(fabsf(err) <= double_ulps); if (fail) { if (ftz || relaxedMode) { // retry per section 6.5.3.2 - if (IsDoubleResultSubnormal(correct, - f->double_ulps)) + if (IsDoubleResultSubnormal(correct, double_ulps)) { fail = fail && (test != 0.0); if (!fail) err = 0.0f; diff --git a/test_conformance/printf/test_printf.cpp b/test_conformance/printf/test_printf.cpp index a98a6efc..38333175 100644 --- a/test_conformance/printf/test_printf.cpp +++ b/test_conformance/printf/test_printf.cpp @@ -247,7 +247,7 @@ cl_program makeMixedFormatPrintfProgram(cl_kernel* kernel_ptr, }; std::array, 2> formats = { - { { "%f", "%e", "%g", "%.13a", "%F", "%E", "%G", "%.13A" }, + { { "%.13f", "%e", "%g", "%.13a", "%.13F", "%E", "%G", "%.13A" }, { "%d", "%i", "%u", "%x", "%o", "%X" } } }; std::vector data_before(2 + genrand_int32(gMTdata) % 8); diff --git a/test_conformance/printf/util_printf.cpp b/test_conformance/printf/util_printf.cpp index 803f13ab..f982f15e 100644 --- a/test_conformance/printf/util_printf.cpp +++ b/test_conformance/printf/util_printf.cpp @@ -19,7 +19,7 @@ #include "test_printf.h" #include #include - +#include // Helpers for generating runtime reference results static void intRefBuilder(printDataGenParameters&, char*, const size_t); @@ -1743,10 +1743,14 @@ size_t verifyOutputBuffer(char *analysisBuffer,testCase* pTestCase,size_t testId else if (pTestCase->_correctBuffer[testId] == "INF") return strcmp(analysisBuffer, "INF") && strcmp(analysisBuffer, "INFINITY"); - else if (pTestCase->_correctBuffer[testId] == "nan") - return strcmp(analysisBuffer, "nan") && strcmp(analysisBuffer, "-nan"); - else if (pTestCase->_correctBuffer[testId] == "NAN") - return strcmp(analysisBuffer, "NAN") && strcmp(analysisBuffer, "-NAN"); + else if (pTestCase->_correctBuffer[testId] == "nan" + || pTestCase->_correctBuffer[testId] == "NAN") + { + std::string pattern = + R"(-?)" + pTestCase->_correctBuffer[testId] + R"((\(.*\))?)"; + std::regex nanRegex(pattern); + return !std::regex_match(analysisBuffer, nanRegex); + } return strcmp(analysisBuffer, pTestCase->_correctBuffer[testId].c_str()); } diff --git a/test_conformance/spir/CMakeLists.txt b/test_conformance/spir/CMakeLists.txt index 1ac49ac3..74eb6ec8 100644 --- a/test_conformance/spir/CMakeLists.txt +++ b/test_conformance/spir/CMakeLists.txt @@ -1,6 +1,6 @@ -set(SPIR_OUT ${CONFORMANCE_PREFIX}spir${CONFORMANCE_SUFFIX}) +set(MODULE_NAME SPIR) -set (SPIR_SOURCES +set (${MODULE_NAME}_SOURCES main.cpp datagen.cpp run_build_test.cpp @@ -8,17 +8,14 @@ set (SPIR_SOURCES kernelargs.cpp ) -add_executable(${SPIR_OUT} - ${SPIR_SOURCES}) +include(../CMakeCommon.txt) if(UNIX) - target_compile_options(${SPIR_OUT} PRIVATE -fexceptions -frtti) + target_compile_options(${${MODULE_NAME}_OUT} PRIVATE -fexceptions -frtti) elseif(MSVC) - target_compile_options(${SPIR_OUT} PRIVATE /GR /EHs /EHc) + target_compile_options(${${MODULE_NAME}_OUT} PRIVATE /GR /EHs /EHc) endif() -target_link_libraries(${SPIR_OUT} harness ${CLConform_LIBRARIES}) - # Need to copy the spir zips to sit beside the executable set(SPIR_FILES @@ -49,8 +46,10 @@ set(SPIR_FILES foreach(input_file ${SPIR_FILES}) add_custom_command( - TARGET ${SPIR_OUT} - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${input_file}" "$/" -) + TARGET ${${MODULE_NAME}_OUT} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${input_file}" "$/" + ) endforeach(input_file) + +install(FILES ${SPIR_FILES} DESTINATION ${CMAKE_INSTALL_BINDIR}/$) diff --git a/test_conformance/spir/main.cpp b/test_conformance/spir/main.cpp index 9a13b405..77754a2f 100644 --- a/test_conformance/spir/main.cpp +++ b/test_conformance/spir/main.cpp @@ -6005,7 +6005,7 @@ public: clContextWrapper context; clCommandQueueWrapper queue; size_t num_modules = m_moduleNames.size(); - std::vector programs(num_modules); + std::vector programs(num_modules); create_context_and_queue(dev, &context, &queue); for (size_t i=0; i 0) { - argList[argCount] = argv[i]; - argCount++; + for (int j = i; j < (argc - argsRemoveNum); ++j) + argv[j] = argv[j + argsRemoveNum]; + + argc -= argsRemoveNum; + --i; } } - return argCount; } int main(int argc, const char *argv[]) @@ -147,9 +173,9 @@ int main(int argc, const char *argv[]) return 0; } - const char **argList = (const char **)calloc(argc, sizeof(char *)); - size_t argCount = parseParams(argc, argv, argList); - if (argCount == 0) return 0; + parseParams(argc, argv); + + if (argc == 0) return 0; return runTestHarness(argc, argv, test_registry::getInstance().num_tests(), test_registry::getInstance().definitions(), false, 0); diff --git a/test_conformance/vulkan/test_vulkan_api_consistency.cpp b/test_conformance/vulkan/test_vulkan_api_consistency.cpp index a148c5d3..7410cc7f 100644 --- a/test_conformance/vulkan/test_vulkan_api_consistency.cpp +++ b/test_conformance/vulkan/test_vulkan_api_consistency.cpp @@ -216,23 +216,27 @@ struct ConsistencyExternalImageTest : public VulkanTestBase getSupportedVulkanExternalMemoryHandleTypeList( vkDevice->getPhysicalDevice())[0]; - VulkanImageTiling vulkanImageTiling = - vkClExternalMemoryHandleTilingAssumption( - device, vkExternalMemoryHandleType, &errNum); + 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); + *vulkanImageTiling, 1, vkExternalMemoryHandleType); const VulkanMemoryTypeList& memoryTypeList = vkImage2D.getMemoryTypeList(); - uint64_t totalImageMemSize = vkImage2D.getSize(); 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 : %ld\n", totalImageMemSize); + log_info("Image size : %ld\n", vkImage2D.getSize()); VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(*vkDevice, vkImage2D, memoryTypeList[0], @@ -293,14 +297,12 @@ struct ConsistencyExternalImageTest : public VulkanTestBase const VkImageCreateInfo VulkanImageCreateInfo = vkImage2D.getVkImageCreateInfo(); - errNum = getCLImageInfoFromVkImageInfo(&VulkanImageCreateInfo, - totalImageMemSize, &img_format, - &image_desc); - if (errNum != CL_SUCCESS) - { - log_error("getCLImageInfoFromVkImageInfo failed!!!"); - return TEST_FAIL; - } + 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; @@ -376,6 +378,10 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase 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; @@ -391,6 +397,7 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR, (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR, }; + switch (semaphoreHandleType) { #ifdef _WIN32 @@ -399,8 +406,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase " Opaque NT handles are only supported on Windows\n"); handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType); handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType); - errNum = check_external_semaphore_handle_type( - device, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR); sema_props1.push_back( (cl_semaphore_properties_khr) CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR); @@ -415,8 +420,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase "Windows\n"); handle1 = vkVk2Clsemaphore.getHandle(semaphoreHandleType); handle2 = vkCl2Vksemaphore.getHandle(semaphoreHandleType); - errNum = check_external_semaphore_handle_type( - device, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR); sema_props1.push_back( (cl_semaphore_properties_khr) CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR); @@ -430,8 +433,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: fd1 = (int)vkVk2Clsemaphore.getHandle(semaphoreHandleType); fd2 = (int)vkCl2Vksemaphore.getHandle(semaphoreHandleType); - errNum = check_external_semaphore_handle_type( - device, CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR); sema_props1.push_back( (cl_semaphore_properties_khr) CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR); @@ -444,8 +445,6 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: fd1 = -1; fd2 = -1; - errNum = check_external_semaphore_handle_type( - device, CL_SEMAPHORE_HANDLE_SYNC_FD_KHR); sema_props1.push_back((cl_semaphore_properties_khr) CL_SEMAPHORE_HANDLE_SYNC_FD_KHR); sema_props1.push_back((cl_semaphore_properties_khr)fd1); @@ -461,7 +460,7 @@ struct ConsistencyExternalSemaphoreTest : public VulkanTestBase if (CL_SUCCESS != errNum) { throw std::runtime_error( - "Unsupported external sempahore handle type\n "); + "Unsupported external semaphore handle type\n "); } sema_props1.push_back((cl_semaphore_properties_khr) CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR); diff --git a/test_conformance/vulkan/test_vulkan_api_consistency_for_1dimages.cpp b/test_conformance/vulkan/test_vulkan_api_consistency_for_1dimages.cpp index a90d7754..b6797f0c 100644 --- a/test_conformance/vulkan/test_vulkan_api_consistency_for_1dimages.cpp +++ b/test_conformance/vulkan/test_vulkan_api_consistency_for_1dimages.cpp @@ -73,23 +73,28 @@ struct ConsistencyExternalImage1DTest : public VulkanTestBase getSupportedVulkanExternalMemoryHandleTypeList( vkDevice->getPhysicalDevice())[0]; - VulkanImageTiling vulkanImageTiling = - vkClExternalMemoryHandleTilingAssumption( - device, vkExternalMemoryHandleType, &errNum); + 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; + } + VulkanImage1D vkImage1D = VulkanImage1D(*vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, - vulkanImageTiling, 1, vkExternalMemoryHandleType); + *vulkanImageTiling, 1, vkExternalMemoryHandleType); const VulkanMemoryTypeList& memoryTypeList = vkImage1D.getMemoryTypeList(); - uint64_t totalImageMemSize = vkImage1D.getSize(); 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 : %lu\n", totalImageMemSize); + log_info("Image size : %lu\n", vkImage1D.getSize()); VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(*vkDevice, vkImage1D, memoryTypeList[0], @@ -150,14 +155,12 @@ struct ConsistencyExternalImage1DTest : public VulkanTestBase const VkImageCreateInfo VulkanImageCreateInfo = vkImage1D.getVkImageCreateInfo(); - errNum = getCLImageInfoFromVkImageInfo(&VulkanImageCreateInfo, - totalImageMemSize, &img_format, - &image_desc); - if (errNum != CL_SUCCESS) - { - log_error("getCLImageInfoFromVkImageInfo failed!!!"); - return TEST_FAIL; - } + auto layout = vkImage1D.getSubresourceLayout(); + errNum = getCLImageInfoFromVkImageInfo( + device, &VulkanImageCreateInfo, &img_format, &image_desc, + vulkanImageTiling == VULKAN_IMAGE_TILING_LINEAR ? &layout + : nullptr); + test_error_fail(errNum, "getCLImageInfoFromVkImageInfo failed!!!"); clMemWrapper image; @@ -168,16 +171,6 @@ struct ConsistencyExternalImage1DTest : public VulkanTestBase test_error(errNum, "Unable to create Image with Properties"); image.reset(); - // Passing NULL properties and a valid image_format and image_desc - image = clCreateImageWithProperties(context, NULL, CL_MEM_READ_WRITE, - &img_format, &image_desc, NULL, - &errNum); - test_error(errNum, - "Unable to create image with NULL properties " - "with valid image format and image desc"); - - image.reset(); - // Passing image_format as NULL image = clCreateImageWithProperties(context, extMemProperties.data(), CL_MEM_READ_WRITE, NULL, diff --git a/test_conformance/vulkan/test_vulkan_api_consistency_for_3dimages.cpp b/test_conformance/vulkan/test_vulkan_api_consistency_for_3dimages.cpp index 0beb8d18..e84954e9 100644 --- a/test_conformance/vulkan/test_vulkan_api_consistency_for_3dimages.cpp +++ b/test_conformance/vulkan/test_vulkan_api_consistency_for_3dimages.cpp @@ -76,23 +76,27 @@ struct ConsistencyExternalImage3DTest : public VulkanTestBase getSupportedVulkanExternalMemoryHandleTypeList( vkDevice->getPhysicalDevice())[0]; - VulkanImageTiling vulkanImageTiling = - vkClExternalMemoryHandleTilingAssumption( - device, vkExternalMemoryHandleType, &errNum); + 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; + } VulkanImage3D vkImage3D = VulkanImage3D( *vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height, depth, - vulkanImageTiling, 1, vkExternalMemoryHandleType); + *vulkanImageTiling, 1, vkExternalMemoryHandleType); const VulkanMemoryTypeList& memoryTypeList = vkImage3D.getMemoryTypeList(); - uint64_t totalImageMemSize = vkImage3D.getSize(); 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 : %lu\n", totalImageMemSize); + log_info("Image size : %lu\n", vkImage3D.getSize()); VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(*vkDevice, vkImage3D, memoryTypeList[0], @@ -153,14 +157,12 @@ struct ConsistencyExternalImage3DTest : public VulkanTestBase const VkImageCreateInfo VulkanImageCreateInfo = vkImage3D.getVkImageCreateInfo(); - errNum = getCLImageInfoFromVkImageInfo(&VulkanImageCreateInfo, - totalImageMemSize, &img_format, - &image_desc); - if (errNum != CL_SUCCESS) - { - log_error("getCLImageInfoFromVkImageInfo failed!!!"); - return TEST_FAIL; - } + auto layout = vkImage3D.getSubresourceLayout(); + errNum = getCLImageInfoFromVkImageInfo( + device, &VulkanImageCreateInfo, &img_format, &image_desc, + vulkanImageTiling == VULKAN_IMAGE_TILING_LINEAR ? &layout + : nullptr); + test_error_fail(errNum, "getCLImageInfoFromVkImageInfo failed!!!"); clMemWrapper image; @@ -171,16 +173,6 @@ struct ConsistencyExternalImage3DTest : public VulkanTestBase test_error(errNum, "Unable to create Image with Properties"); image.reset(); - // Passing NULL properties and a valid image_format and image_desc - image = clCreateImageWithProperties(context, NULL, CL_MEM_READ_WRITE, - &img_format, &image_desc, NULL, - &errNum); - test_error(errNum, - "Unable to create image with NULL properties " - "with valid image format and image desc"); - - image.reset(); - // Passing image_format as NULL image = clCreateImageWithProperties(context, extMemProperties.data(), CL_MEM_READ_WRITE, NULL, diff --git a/test_conformance/vulkan/test_vulkan_interop_buffer.cpp b/test_conformance/vulkan/test_vulkan_interop_buffer.cpp index a05dc6ed..5f7c7f48 100644 --- a/test_conformance/vulkan/test_vulkan_interop_buffer.cpp +++ b/test_conformance/vulkan/test_vulkan_interop_buffer.cpp @@ -98,8 +98,8 @@ int run_test_with_two_queue( cl_mem error_1 = nullptr; cl_kernel update_buffer_kernel = nullptr; cl_kernel kernel_cq = nullptr; - clExternalSemaphore *clVk2CLExternalSemaphore = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore = NULL; + clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr; const char *program_source_const = kernel_text_numbuffer_2; size_t program_source_length = strlen(program_source_const); cl_program program = clCreateProgramWithSource( @@ -147,12 +147,11 @@ int run_test_with_two_queue( } else { - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, true); + clVk2CLExternalSemaphore = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId); + + clCl2VkExternalSemaphore = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); } const uint32_t maxIter = innerIterations; @@ -442,8 +441,8 @@ int run_test_with_one_queue( uint8_t *error_2 = nullptr; cl_mem error_1 = nullptr; cl_kernel update_buffer_kernel; - clExternalSemaphore *clVk2CLExternalSemaphore = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore = NULL; + clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr; int err = CL_SUCCESS; const std::vector @@ -482,12 +481,11 @@ int run_test_with_one_queue( } else { - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, true); + clVk2CLExternalSemaphore = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId); + + clCl2VkExternalSemaphore = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); } const uint32_t maxIter = innerIterations; @@ -747,8 +745,8 @@ int run_test_with_multi_import_same_ctx( cl_mem error_1 = nullptr; int numImports = numBuffers; cl_kernel update_buffer_kernel; - clExternalSemaphore *clVk2CLExternalSemaphore = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore = NULL; + clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr; int err = CL_SUCCESS; int calc_max_iter; @@ -787,12 +785,11 @@ int run_test_with_multi_import_same_ctx( } else { - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, true); + clVk2CLExternalSemaphore = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId); + + clCl2VkExternalSemaphore = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); } const uint32_t maxIter = innerIterations; @@ -1084,10 +1081,10 @@ int run_test_with_multi_import_diff_ctx( int numImports = numBuffers; cl_kernel update_buffer_kernel1[MAX_IMPORTS]; cl_kernel update_buffer_kernel2[MAX_IMPORTS]; - clExternalSemaphore *clVk2CLExternalSemaphore = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore = NULL; - clExternalSemaphore *clVk2CLExternalSemaphore2 = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore2 = NULL; + clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr; + clExternalImportableSemaphore *clVk2CLExternalSemaphore2 = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore2 = nullptr; int err = CL_SUCCESS; int calc_max_iter; bool withOffset; @@ -1128,19 +1125,19 @@ int run_test_with_multi_import_diff_ctx( } else { - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, - context, vkExternalSemaphoreHandleType, - deviceId, false); + clVk2CLExternalSemaphore = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId); - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore2, vkVk2CLSemaphore, - context2, vkExternalSemaphoreHandleType, - deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore2, vkCl2VkSemaphore, - context2, vkExternalSemaphoreHandleType, - deviceId, false); + clCl2VkExternalSemaphore = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); + + clVk2CLExternalSemaphore2 = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context2, vkExternalSemaphoreHandleType, + deviceId); + + clCl2VkExternalSemaphore2 = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context2, vkExternalSemaphoreHandleType, + deviceId); } const uint32_t maxIter = innerIterations; diff --git a/test_conformance/vulkan/test_vulkan_interop_image.cpp b/test_conformance/vulkan/test_vulkan_interop_image.cpp index c2f2727d..a73dde3f 100644 --- a/test_conformance/vulkan/test_vulkan_interop_image.cpp +++ b/test_conformance/vulkan/test_vulkan_interop_image.cpp @@ -254,13 +254,14 @@ int run_test_with_two_queue( VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *clVk2CLExternalSemaphore = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore = NULL; + clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr; - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, context, - vkExternalSemaphoreHandleType, deviceId, true); + clVk2CLExternalSemaphore = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId); + + clCl2VkExternalSemaphore = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); std::vector vkImage2DListDeviceMemory1; std::vector vkImage2DListDeviceMemory2; @@ -368,16 +369,22 @@ int run_test_with_two_queue( } log_info("External memory handle type: %d \n", vkExternalMemoryHandleType); - VulkanImageTiling vulkanImageTiling = + auto vulkanImageTiling = vkClExternalMemoryHandleTilingAssumption( deviceId, vkExternalMemoryHandleTypeList[emhtIdx], &err); ASSERT_SUCCESS(err, "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 vkDummyImage2D( vkDevice, vkFormatList[0], widthList[0], - heightList[0], vulkanImageTiling, 1, + heightList[0], *vulkanImageTiling, 1, vkExternalMemoryHandleType); const VulkanMemoryTypeList &memoryTypeList = vkDummyImage2D.getMemoryTypeList(); @@ -405,7 +412,7 @@ int run_test_with_two_queue( { VulkanImage2D vkImage2D( vkDevice, vkFormat, width, height, - vulkanImageTiling, numMipLevels, + *vulkanImageTiling, numMipLevels, vkExternalMemoryHandleType); ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize); totalImageMemSize = @@ -414,7 +421,7 @@ int run_test_with_two_queue( } VulkanImage2DList vkImage2DList( num2DImages, vkDevice, vkFormat, width, height, - vulkanImageTiling, numMipLevels, + *vulkanImageTiling, numMipLevels, vkExternalMemoryHandleType); for (size_t bIdx = 0; bIdx < num2DImages; bIdx++) { @@ -436,7 +443,7 @@ int run_test_with_two_queue( vkDevice, vkImage2DList); VulkanImage2DList vkImage2DList2( num2DImages, vkDevice, vkFormat, width, height, - vulkanImageTiling, numMipLevels, + *vulkanImageTiling, numMipLevels, vkExternalMemoryHandleType); for (size_t bIdx = 0; bIdx < num2DImages; bIdx++) { @@ -867,13 +874,14 @@ int run_test_with_one_queue( VulkanSemaphore vkVk2CLSemaphore(vkDevice, vkExternalSemaphoreHandleType); VulkanSemaphore vkCl2VkSemaphore(vkDevice, vkExternalSemaphoreHandleType); - clExternalSemaphore *clVk2CLExternalSemaphore = NULL; - clExternalSemaphore *clCl2VkExternalSemaphore = NULL; + clExternalImportableSemaphore *clVk2CLExternalSemaphore = nullptr; + clExternalExportableSemaphore *clCl2VkExternalSemaphore = nullptr; - CREATE_OPENCL_SEMAPHORE(clVk2CLExternalSemaphore, vkVk2CLSemaphore, context, - vkExternalSemaphoreHandleType, deviceId, false); - CREATE_OPENCL_SEMAPHORE(clCl2VkExternalSemaphore, vkCl2VkSemaphore, context, - vkExternalSemaphoreHandleType, deviceId, true); + clVk2CLExternalSemaphore = new clExternalImportableSemaphore( + vkVk2CLSemaphore, context, vkExternalSemaphoreHandleType, deviceId); + + clCl2VkExternalSemaphore = new clExternalExportableSemaphore( + vkCl2VkSemaphore, context, vkExternalSemaphoreHandleType, deviceId); std::vector vkImage2DListDeviceMemory1; std::vector vkImage2DListDeviceMemory2; @@ -982,16 +990,21 @@ int run_test_with_one_queue( continue; } - VulkanImageTiling vulkanImageTiling = + auto vulkanImageTiling = vkClExternalMemoryHandleTilingAssumption( deviceId, vkExternalMemoryHandleTypeList[emhtIdx], &err); test_error_and_cleanup( err, CLEANUP, "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 vkDummyImage2D( vkDevice, vkFormatList[0], widthList[0], - heightList[0], vulkanImageTiling, 1, + heightList[0], *vulkanImageTiling, 1, vkExternalMemoryHandleType); const VulkanMemoryTypeList &memoryTypeList = vkDummyImage2D.getMemoryTypeList(); @@ -1018,7 +1031,7 @@ int run_test_with_one_queue( { VulkanImage2D vkImage2D( vkDevice, vkFormat, width, height, - vulkanImageTiling, numMipLevels, + *vulkanImageTiling, numMipLevels, vkExternalMemoryHandleType); ASSERT_LEQ(vkImage2D.getSize(), maxImage2DSize); totalImageMemSize = @@ -1027,7 +1040,7 @@ int run_test_with_one_queue( } VulkanImage2DList vkImage2DList( num2DImages, vkDevice, vkFormat, width, height, - vulkanImageTiling, numMipLevels, + *vulkanImageTiling, numMipLevels, vkExternalMemoryHandleType); for (size_t bIdx = 0; bIdx < vkImage2DList.size(); bIdx++) @@ -1053,7 +1066,7 @@ int run_test_with_one_queue( VulkanImage2DList vkImage2DList2( num2DImages, vkDevice, vkFormat, width, height, - vulkanImageTiling, numMipLevels, + *vulkanImageTiling, numMipLevels, vkExternalMemoryHandleType); for (size_t bIdx = 0; bIdx < vkImage2DList2.size(); bIdx++) diff --git a/test_conformance/vulkan/vulkan_interop_common.hpp b/test_conformance/vulkan/vulkan_interop_common.hpp index 6f4d9155..4e285335 100644 --- a/test_conformance/vulkan/vulkan_interop_common.hpp +++ b/test_conformance/vulkan/vulkan_interop_common.hpp @@ -42,6 +42,7 @@ extern bool debug_trace; extern bool useSingleImageKernel; extern bool useDeviceLocal; +extern bool useValidationLayers; extern bool disableNTHandleType; #endif // _vulkan_interop_common_hpp_ diff --git a/test_conformance/vulkan/vulkan_test_base.h b/test_conformance/vulkan/vulkan_test_base.h index 82b8e639..8c7b07cc 100644 --- a/test_conformance/vulkan/vulkan_test_base.h +++ b/test_conformance/vulkan/vulkan_test_base.h @@ -40,8 +40,8 @@ struct VulkanTestBase cl_command_queue queue, cl_int nelems) : device(device), context(context), num_elems(nelems) { - vkDevice.reset( - new VulkanDevice(getAssociatedVulkanPhysicalDevice(device))); + vkDevice.reset(new VulkanDevice( + getAssociatedVulkanPhysicalDevice(device, useValidationLayers))); cl_platform_id platform; cl_int error = clGetDeviceInfo(device, CL_DEVICE_PLATFORM, @@ -101,7 +101,7 @@ int MakeAndRunTest(cl_device_id device, cl_context context, return TEST_SKIPPED_ITSELF; } - if (!checkVkSupport()) + if (!checkVkSupport(useValidationLayers)) { log_info("Vulkan supported GPU not found \n"); log_info("TEST SKIPPED \n");